// package com.libc.yygh.common.utils;
//
// import cn.hutool.core.date.DateTime;
// import cn.hutool.core.date.DateUtil;
// import cn.hutool.core.util.NumberUtil;
// import cn.hutool.core.util.XmlUtil; 
// import org.w3c.dom.Document;
// import org.w3c.dom.Element;
// import org.w3c.dom.Node;
// import org.w3c.dom.NodeList;
//
// import java.text.ParseException;
// import java.time.LocalDate;
// import java.time.LocalDateTime;
// import java.time.LocalTime;
// import java.time.temporal.ChronoUnit;
// import java.util.*;
// import java.util.concurrent.ExecutionException;
// import java.util.concurrent.atomic.AtomicReference;
// import java.util.concurrent.locks.Condition;
// import java.util.concurrent.locks.Lock;
// import java.util.concurrent.locks.ReentrantLock;
//
// /**
//  * *熙软科技：薪资计算逻辑处理类
//  *
//  * @version 1.0<br>
//  * @packagename: com.xisoft.hr.test<br>
//  * @author: LiBencheng<br>
//  * @computer: licheng<br>
//  * @date: Created on 2021/9/25$9:24<br>
//  */
// public class FormulaHandler
// {
//     private static ThreadLocal< FormulaHandler > formulaHandler = new ThreadLocal< FormulaHandler >();
//
//     /** 日志調試 */
//     private Boolean isDebug = Boolean.TRUE;
//     private Lock lock = new ReentrantLock();
//     private Condition c1 = lock.newCondition();
//     private volatile String calcAlgorithmStr = "";
//
//     private Map< String,Object > salaryDataMap = null;
//     private String formulaKey = null;
//     private String formula_parse = null;
//
//     public static void main (String[] args) throws ExecutionException, InterruptedException
//     {
//         //ABS{A.F_24}
//         // String string = "QUJTe0EuRl8yNH0=";
//         // // <data><abs>a.f_24</abs></data>
//         // string = "PGRhdGE+PGFicz5hLmZfMjQ8L2Ficz48L2RhdGE+";
//         // String formulaStr = new String(Base64.getDecoder()
//         //                                      .decode(string),
//         //                                StandardCharsets.UTF_8);
//         // System.out.println(formulaStr);
//         List< String > formulaList = new ArrayList< String >();
//         // formulaList.add("<data><round><ceil><ceil>123.0</ceil></ceil>,3</round></data>");
//         // formulaList.add("<data><ceil>123.0</ceil>-<floor>12.4</floor></data>");
//         // formulaList.add("<data><ceil>123.0</ceil>-<floor>12.4</floor></data>");
//         // formulaList.add("<data><ceil>123.0</ceil>-12.4</data>");
//         // formulaList.add("<data><abs><ceil>12.4</ceil>-3</abs></data>");
//         // formulaList.add("<data><round>0,3</round></data></data>");
//         // formulaList.add("<data><isnull>null,102</isnull></data>");
//         // formulaList.add("<data><floor>12.4</floor></data>");
//         // formulaList.add("<data><data><ceil>12.4</ceil>-36</data></data>");
//         // formulaList.add("<data><abs>-12.4</abs></data>");
//         // formulaList.add("<data><abs>3-12.4</abs></data>");
//         // formulaList.add("<data><abs><ceil>12.4</ceil>-3-3</abs></data>");
//         // formulaList.add("<data><abs>3-<ceil>12.4</ceil></abs></data>");
//         // formulaList.add("<data><abs>3-3-<ceil>12.4</ceil></abs></data>");
//         // formulaList.add("<data><abs>3-<ceil>18</ceil>-<ceil>12.4</ceil></abs></data>");
//         // formulaList.add("<data><abs>3*<ceil>18</ceil>/<ceil>12.4</ceil></abs></data>");
//         //
//         // formulaList.add("<data><if>30>50</if><then>100</then>" +
//         //                         "<else><abs><round>-200,3</round></abs></else></data>");
//         // formulaList.add("<data><if>30>50</if><then>100</then><else><ceil>200.3</ceil></else></data>");
//         // formulaList.add("<data><if>30<![CDATA[>]]>50</if><then>100</then>" +
//         //                         "<else><ceil>200.3</ceil></else></data>");
//         //
//         // formulaList.add("<data><if>30<![CDATA[>]]>50</if><then>100</then>" +
//         //                         "<elseif>30<![CDATA[<]]>50</elseif><then>800" +
//         //                         "</then><else><ceil>200.3</ceil></else></data>");
//         //
//         // formulaList.add("<data><if><abs>-300</abs><![CDATA[>]]>50</if><then>100</then><else>200</else
//         // ></data>");
//         // formulaList.add("<data><if><abs>-30</abs>>50</if><then>100</then><else><abs><floor>-200" +
//         //                         ".5</floor></abs></else></data>");
//         //
//         // formulaList.add("<data><if><substring>-5000,0,3</substring><![CDATA[<]]>50</if>" +
//         //                         "<then>100</then><else>-200.5</else></data>");
//         // formulaList.add("<data><if>80<![CDATA[<]]><substring>-5000,03</substring></if>" +
//         //                         "<then>100</then><else>-200.5</else></data > ");
//         // formulaList.add("<data><if>30<![CDATA[<]]>50</if>" +
//         //                         "<then>100</then><else><ceil>200.3</ceil></else></data>");
//         // formulaList.add("<data><if>30<![CDATA[<]]><ceil>200
//         // .3</ceil></if><then>100</then><else><ceil>200 " +
//         //                         ".3</ceil></else></data>");
//         // formulaList.add("<data><if>q30<![CDATA[<]]><ceil>200.3</ceil></if><then><abs>3-12" +
//         //                         ".4</abs></then><else><ceil>200.3+600</ceil></else></data>");
//         // formulaList.add("<data><if>(<round>3.5,4</round>-<floor>2.3</floor>)<![CDATA[>]]><ceil>2" +
//         //                         ".9</ceil></if><then>200</then><else>500</else></data>");
//
//         // formulaList.add("<data><if><data><if>30<![CDATA[<]]><ceil>200</ceil></if>" +
//         //                         "<then>100</then><else>200</else>" +
//         //                         "</data><![CDATA[<>]]>20</if>" +
//         //                         "<then>800</then><else>500</else></data>");
//
//         // formulaList.add("<data><if><if>30<![CDATA[<]]><ceil>200</ceil></if>" +
//         //                         "<then>100</then><else>200</else>" +
//         //                         "<![CDATA[<>]]>30</if>" +
//         //                         "<then>800</then><else>500</else></data>");
//
//         // formulaList.add("<data><if>123<![CDATA[<>]]>[123,456]</if>" +
//         //                         "<then>100</then><else>-200.5</else></data>");
//         //
//         // formulaList.add("<data><if>123<![CDATA[<>]]>['123','456']</if>" +
//         //                         "<then>100</then><else>-200.5</else></data>");
//         // formulaList.add("<data><if>(<round>600.6,0</round>-<round>600.6,0</round>)><round>600.6," +
//         //                         "0</round></if><then>500-200</then><else>400</else></data>");
//
//         // formulaList.add("<data><if>(123 <![CDATA[<>]]> ['124,'125'] and 123  ='124')</if>" +
//         //                         "<then>100</then><else><ceil>200.3</ceil></else></data>");
//         // formulaList.add("<data><if>(123 != ['123,'125'] or 123  ='124') </if>" +
//         //                         "<then>100</then><else><ceil>200.3</ceil></else></data>");
//         // formulaList.add("<data><if>(123 = ['123,'125'] and 123  ='123') and 125=125 </if>" +
//         //                         "<then>100</then><else><ceil>200.3</ceil></else></data>");
//         // formulaList.add("<data><if> (123  != ['123,'125'] and 222  ='222' " +
//         //                         "or 333 =['333','000'] and 444='444' and 555 ='555')  </if>" +
//         //                         "<then>100</then><else><ceil>200.3</ceil></else></data>");
//
//         // formulaList.add("<data><substring>0,0,5</substring>+<substring>0,0,2</substring></data>");
//         // formulaList.add("<data>(<substring>0,0,5</substring>+<substring>0,0,2</substring>)*3</data>");
//         // formulaList.add("<data>(<substring>0,0,5</substring>+<substring>0,0,2</substring> )*9</data>");
//         //错误格式的公式
//         // formulaList.add("<data><abs><ceil>12.4</ceil>-3</abs></data></data>");
//         // formulaList.add("<data><round>0,3</round></data></data>");
//         // formulaList.add("<data><abs>3-3<ceil>12.4</ceil></abs></data>");
//         // formulaList.add("<data><if>30>50</if><then>100</then><else><ceil>200.3</ceil></else></data>");
//         // formulaList.add("<data><if>30>50</if><then>100</then>5555<else><ceil>200
//         // .3</ceil></else></data>");
//         // formulaList.add("<data><if>11<![CDATA[>]]>5</if><then>(2395+140.24+35+90)/30*11+150</then><else>(2395+140
//         // .24+35+90)/30*11</else></data>");
//         // formulaList.add("<data><if>(7500-0=0)   and
//         // (f6ef4aa9-86b6-4484-8e97-a248952091da='f6ef4aa9-86b6-4484-8e97-a248952091da' or
//         // f6ef4aa9-86b6-4484-8e97-a248952091da='cc95da72-017d-4237-bb14-b330275ffb94')</if><then>4330*0
//         // .005</then><else>0</else></data>");
//         // formulaList.add("<data><if>(0-0=0)   and (f6ef4aa9-86b6-4484-8e97-a248952091da='f6ef4aa9-86b6-4484-8e97" +
//         //                         "-a248952091da' or f6ef4aa9-86b6-4484-8e97-a248952091da='cc95da72-017d-4237-bb14" +
//         //                         "-b330275ffb94')</if><then>1500*0.005</then><else>0</else></data>");
//         // formulaList.add("<data><if>(0-0=0)   and (f6ef4aa9-86b6-4484-8e97-a248952091da=['f6ef4aa9-86b6-4484-8e97" +
//         //                         "-a248952091da' ,'cc95da72-017d-4237-bb14-b330275ffb94'])</if><then>1500*0" +
//         //                         ".005</then><else>0</else></data>");
//         // formulaList.add("<data><if>(0 =0 or 0=0)   and
//         // (f6ef4aa9-86b6-4484-8e97-a248952091da='f6ef4aa9-86b6-4484-8e97" +
//         //                         "-a248952091da' or f6ef4aa9-86b6-4484-8e97-a248952091da='cc95da72-017d-4237-bb14" +
//         //                         "-b330275ffb94')</if><then>1500*0.005</then><else>0</else></data>");
//
//         // formulaList.add("<data><last_day><add_month><sysdate>nowdate</sysdate>," +
//         //                         "-2</add_month></last_day>-<to_day>2022-01-16</to_day></data>");
//         // formulaList.add("<data><if>( 2022-04-32 = 2022-04-32) and (0='f6ef4aa9-86b6-4484-8e97-a248952091da' ," +
//         //                         "'cc95da72-017d-4237-bb14-b330275ffb94')</if><then>0*0" +
//         //                         ".005</then><else>0</else></data>\n");
//         // formulaList.add("<data>2-+7</data>");
//         // formulaList.add("<data>2-+7</data>");
//         // formulaList.add("<data><if>0<![CDATA[<]]>3<![CDATA[<]]>2</if><then>1111</then><elseif>0='0'</elseif><then" +
//         //                         ">4444</then><else>0000</else></data>");
//         // Document document = XmlUtil.readXML(formulaList.get(0));
//         // if (!isXmlDocument(formulaList.get(0)))
//         // { throw new RuntimeException(formatErrStr(SalaryMsg.FORMULA_FUN_ERROR)); }
//         // formulaList.add("<data><if>15265.26<![CDATA[<]]>8958.5</if><then>15265.26</then>" +
//         //                         "<elseif>8958.5<![CDATA[<]]>3053.05</elseif><then>3053.05</then>" +
//         //                         "<else>8958.5</else></data>");
//         // formulaList.add("<data><last_day><add_month><sysdate>nowdate</sysdate>,-2</add_month></last_day></data>");
//         // formulaList.add("<data><last_day><sysdate>nowdate</sysdate></last_day></data>");
//         // formulaList.add("<data>1525628.9*247</data>");
//         // formulaList.add("<data>(1620+400+0+0+147.5+185+5+0+200+1240+0)*0.37+0+12+0+0-101.5-9.55-288.8-1010
//         // .14-0-0-7.085375-0-0</data>");
//         // formulaList.add("<data>(1620+400+0+0+147.5+185+5+0+200+1240+0)*0.37 </data>");
//         // formulaList.add("<data> 0+12+0+0-101.5-9.55-288.8-1010.14-0-0-7.085375-0-0</data>");
//         // formulaList.add("<data><if>[人员工作信息.专业技术聘任等级分类]=04</if><then>[薪资发放项目.值班天数]*30</then><elseif>[人员工作信息" +
//         //                         ".专业技术聘任等级分类]=03</elseif><then>[薪资发放项目.值班天数]*50</then><elseif>[人员工作信息" +
//         //                         ".专业技术聘任等级分类]=01</elseif><then>[薪资发放项目.值班天数]*100</then><else>0</else></data>\n");
//         // formulaList.add("<data>1405.075-1405.075375 </data>");
//         // formulaList.add("<data>0-0-0-0-0-0-1</data>");
//         // formulaList.add("<data><if>18<![CDATA[<]]>18</if><then>5</then><else>0</else></data>");
//         // formulaList.add("<data><if><to_year>2011-12-01</to_year>=<to_year><add_month><sysdate>nowdate</sysdate>," +
//         //      "-1</add_month></to_year> and <to_month>2011-12-01</to_month> = " +
//         //      "<to_month><add_month><sysdate>nowdate</sysdate>," +
//         //      "-1</add_month></to_month></if><then><round>2946/<last_day><add_month><sysdate" +
//         //      ">nowdate</sysdate>,
//         //      -1</add_month></last_day>*31+479+0+0+0+0+0+0+0+0+-30+0-0-0-0-0-0" +
//         //      "-64-254-0-400-0-0-0,
//         //      0</round></then><else><round>2946+479+0+0+0+0+0+0+0+0+-30+0-0-0" +
//         //      "-0-0-0-64-254-0-400-0-0-0,0</round></else></data>");
//         // formulaList.add("<data><round>2946+479+0+0+0+0+0+0+0+0+-30+0-0-0-0-0-0-64-254-0-400-0-0-0,0</round></data>");
//         // formulaList.add("<data><if>-1 <![CDATA[>]]> 0</if><then>0</then><else><abs>(-5000+0+0)-(5000*6)" +
//         //                         "-0</abs></else></data>");
//         // formulaList.add("<data><getsubvalue> hr_salary, career_post_salary, is_new='0',  </getsubvalue></data>");
//         // formulaList.add("<data><if><to_year>0</to_year>=<to_year><add_month><sysdate>nowdate</sysdate>," +
//         //                         "-1</add_month></to_year> and <to_year>0</to_year>=<to_year><add_month><sysdate" +
//         //                         ">nowdate</sysdate>,-1</add_month></to_year> and " +
//         //                         "<to_month>0</to_month>=<to_month><add_month><sysdate>nowdate</sysdate>," +
//         //                         "-1</add_month></to_month> and
//         //                         <to_month>0</to_month>=<to_month><add_month><sysdate" +
//         //                         ">nowdate</sysdate>,
//         //                         -1</add_month></to_month></if><then><to_day>0</to_day>-<to_day>0" +
//         //                         "</to_day>+1</then><elseif><to_year>0</to_year>=<to_year><add_month><sysdate
//         //                         >nowdate" +
//         //                         "</sysdate>,-1</add_month></to_year> and " +
//         //                         "<to_year>0</to_year>=<to_year><add_month><sysdate>nowdate</sysdate>," +
//         //                         "-1</add_month></to_year> and <to_month>0</to_month>=<to_month><add_month><sysdate" +
//         //                         ">nowdate</sysdate>,-1</add_month></to_month> and " +
//         //                         "<to_month>0</to_month><![CDATA[>]]><to_month><add_month><sysdate>nowdate</sysdate
//         //                         >," +
//         //                         "-1</add_month></to_month></elseif><then><last_day><add_month><sysdate>nowdate" +
//         //                         "</sysdate>,-1</add_month></last_day>-<to_day>0</to_day>+1</then><elseif><to_year
//         //                         >0" +
//         //                         "</to_year>=<to_year><add_month><sysdate>nowdate</sysdate>,
//         //                         -1</add_month></to_year> " +
//         //                         "and <to_year>0</to_year>=<to_year><add_month><sysdate>nowdate</sysdate>," +
//         //                         "-1</add_month></to_year> and
//         //                         <to_month>0</to_month><![CDATA[<]]><to_month><add_month" +
//         //                         "><sysdate>nowdate</sysdate>,-1</add_month></to_month> and " +
//         //                         "<to_month>0</to_month>=<to_month><add_month><sysdate>nowdate</sysdate>," +
//         //                         "-1</add_month></to_month></elseif><then><to_day>0</to_day></then><elseif><to_year
//         //                         >0" +
//         //                         "</to_year>=<to_year><add_month><sysdate>nowdate</sysdate>,
//         //                         -1</add_month></to_year> " +
//         //                         "and <to_year>0</to_year>=<to_year><add_month><sysdate>nowdate</sysdate>," +
//         //                         "-1</add_month></to_year> and
//         //                         <to_month>0</to_month><![CDATA[<]]><to_month><add_month" +
//         //                         "><sysdate>nowdate</sysdate>,-1</add_month></to_month> and " +
//         //                         "<to_month>0</to_month><![CDATA[>]]><to_month><add_month><sysdate>nowdate</sysdate
//         //                         >," +
//         //                         "-1</add_month></to_month></elseif><then><last_day><add_month><sysdate>nowdate" +
//         //                         "</sysdate>,-1</add_month></last_day></then><elseif><to_year>0</to_year><![CDATA" +
//         //                         "[<]]><to_year><add_month><sysdate>nowdate</sysdate>,-1</add_month></to_year> and " +
//         //                         "<to_year>0</to_year>=<to_year><add_month><sysdate>nowdate</sysdate>," +
//         //                         "-1</add_month></to_year> and <to_month>0</to_month>=<to_month><add_month><sysdate" +
//         //                         ">nowdate</sysdate>,-1</add_month></to_month> and " +
//         //                         "<to_month>0</to_month>=<to_month><add_month><sysdate>nowdate</sysdate>," +
//         //                         "-1</add_month></to_month></elseif><then><to_day>0</to_day>-<to_day>0</to_day>+1" +
//         //                         "</then><elseif><to_year>0</to_year><![CDATA[<]]><to_year><add_month><sysdate
//         //                         >nowdate" +
//         //                         "</sysdate>,-1</add_month></to_year> and " +
//         //                         "<to_year>0</to_year>=<to_year><add_month><sysdate>nowdate</sysdate>," +
//         //                         "-1</add_month></to_year> and <to_month>0</to_month>=<to_month><add_month><sysdate" +
//         //                         ">nowdate</sysdate>,-1</add_month></to_month> and " +
//         //                         "<to_month>0</to_month><![CDATA[>]]><to_month><add_month><sysdate>nowdate</sysdate
//         //                         >," +
//         //                         "-1</add_month></to_month></elseif><then><last_day><add_month><sysdate>nowdate" +
//         //                         "</sysdate>,-1</add_month></last_day>-<to_day>0</to_day>+1</then><elseif><to_year
//         //                         >0" +
//         //                         "</to_year><![CDATA[<]]><to_year><add_month><sysdate>nowdate</sysdate>," +
//         //                         "-1</add_month></to_year> and <to_year>0</to_year>=<to_year><add_month><sysdate" +
//         //                         ">nowdate</sysdate>,-1</add_month></to_year> and " +
//         //                         "<to_month>0</to_month><![CDATA[<]]><to_month><add_month><sysdate>nowdate</sysdate
//         //                         >," +
//         //                         "-1</add_month></to_month> and
//         //                         <to_month>0</to_month>=<to_month><add_month><sysdate" +
//         //                         ">nowdate</sysdate>,
//         //                         -1</add_month></to_month></elseif><then><to_day>0</to_day></then" +
//         //                         "><elseif><to_year>0</to_year><![CDATA[<]]><to_year><add_month><sysdate>nowdate" +
//         //                         "</sysdate>,-1</add_month></to_year> and " +
//         //                         "<to_year>0</to_year>=<to_year><add_month><sysdate>nowdate</sysdate>," +
//         //                         "-1</add_month></to_year> and
//         //                         <to_month>0</to_month><![CDATA[>]]><to_month><add_month" +
//         //                         "><sysdate>nowdate</sysdate>,-1</add_month></to_month> and " +
//         //                         "<to_month>0</to_month><![CDATA[>]]><to_month><add_month><sysdate>nowdate</sysdate
//         //                         >," +
//         //                         "-1</add_month></to_month></elseif><then><last_day><add_month><sysdate>nowdate" +
//         //                         "</sysdate>,-1</add_month></last_day></then><elseif><to_year>0</to_year><![CDATA" +
//         //                         "[<]]><to_year><add_month><sysdate>nowdate</sysdate>,-1</add_month></to_year> and " +
//         //                         "<to_year>0</to_year>=<to_year><add_month><sysdate>nowdate</sysdate>," +
//         //                         "-1</add_month></to_year> and
//         //                         <to_month>0</to_month><![CDATA[>]]><to_month><add_month" +
//         //                         "><sysdate>nowdate</sysdate>,-1</add_month></to_month></elseif><then><last_day" +
//         //                         "><add_month><sysdate>nowdate</sysdate>," +
//         //                         "-1</add_month></last_day></then><elseif><to_year>0</to_year><![CDATA[<]]><to_year" +
//         //                         "><add_month><sysdate>nowdate</sysdate>,-1</add_month></to_year> and " +
//         //                         "<to_year>0</to_year>=<to_year><add_month><sysdate>nowdate</sysdate>," +
//         //                         "-1</add_month></to_year> and<to_month>0</to_month>=<to_month><add_month><sysdate" +
//         //                         ">nowdate</sysdate>,
//         //                         -1</add_month></to_month></elseif><then><to_day>0</to_day></then" +
//         //                         "><else>0</else></data>\n");
//         // formulaList.add("<data><last_day><add_month><sysdate>WORKDATE</sysdate>,-1</add_month></last_day></data>");
//         // formulaList.add("<data><if><to_year>2022-03-01</to_year>=<to_year><add_month><sysdate>nowdate</sysdate>," +
//         //                         "-1</add_month></to_year> and <to_year>2022-04-01</to_year>=<to_year><add_month" +
//         //                         "><sysdate>nowdate</sysdate>,-1</add_month></to_year> and " +
//         //                         "<to_month>2022-03-01</to_month>=<to_month><add_month><sysdate>nowdate</sysdate>," +
//         //                         "-1</add_month></to_month> and
//         //                         <to_month>2022-04-01</to_month>=<to_month><add_month" +
//         //                         "><sysdate>nowdate</sysdate>,
//         //                         -1</add_month></to_month></if><then><to_day>2022-04-01" +
//         //                         "</to_day>-<to_day>2022-03-01</to_day>+1</then><elseif><to_year>2022-03-01
//         //                         </to_year" +
//         //                         ">=<to_year><add_month><sysdate>nowdate</sysdate>,-1</add_month></to_year> and " +
//         //                         "<to_year>2022-04-01</to_year>=<to_year><add_month><sysdate>nowdate</sysdate>," +
//         //                         "-1</add_month></to_year> and <to_month>2022-03-01</to_month>=<to_month><add_month" +
//         //                         "><sysdate>nowdate</sysdate>,-1</add_month></to_month> and " +
//         //                         "<to_month>2022-04-01</to_month><![CDATA[>]]><to_month><add_month><sysdate>nowdate" +
//         //                         "</sysdate>,-1</add_month></to_month></elseif><then><last_day><add_month><sysdate" +
//         //                         ">nowdate</sysdate>,-1</add_month></last_day>-<to_day>2022-03-01</to_day>+1</then" +
//         //                         "><elseif><to_year>2022-03-01</to_year>=<to_year><add_month><sysdate>nowdate
//         //                         </sysdate" +
//         //                         ">,-1</add_month></to_year> and <to_year>2022-04-01</to_year>=<to_year><add_month" +
//         //                         "><sysdate>nowdate</sysdate>,-1</add_month></to_year> and " +
//         //                         "<to_month>2022-03-01</to_month><![CDATA[<]]><to_month><add_month><sysdate>nowdate" +
//         //                         "</sysdate>,-1</add_month></to_month> and " +
//         //                         "<to_month>2022-04-01</to_month>=<to_month><add_month><sysdate>nowdate</sysdate>," +
//         //                         "-1</add_month></to_month></elseif><then><to_day>2022-04-01</to_day></then><elseif" +
//         //                         "><to_year>2022-03-01</to_year>=<to_year><add_month><sysdate>nowdate</sysdate>," +
//         //                         "-1</add_month></to_year> and <to_year>2022-04-01</to_year>=<to_year><add_month" +
//         //                         "><sysdate>nowdate</sysdate>,-1</add_month></to_year> and " +
//         //                         "<to_month>2022-03-01</to_month><![CDATA[<]]><to_month><add_month><sysdate>nowdate" +
//         //                         "</sysdate>,-1</add_month></to_month> and " +
//         //                         "<to_month>2022-04-01</to_month><![CDATA[>]]><to_month><add_month><sysdate>nowdate" +
//         //                         "</sysdate>,-1</add_month></to_month></elseif><then><last_day><add_month><sysdate" +
//         //                         ">nowdate</sysdate>,-1</add_month></last_day></then><elseif><to_year>2022-03-01" +
//         //                         "</to_year><![CDATA[<]]><to_year><add_month><sysdate>nowdate</sysdate>," +
//         //                         "-1</add_month></to_year> and <to_year>2022-04-01</to_year>=<to_year><add_month" +
//         //                         "><sysdate>nowdate</sysdate>,-1</add_month></to_year> and " +
//         //                         "<to_month>2022-03-01</to_month>=<to_month><add_month><sysdate>nowdate</sysdate>," +
//         //                         "-1</add_month></to_month> and
//         //                         <to_month>2022-04-01</to_month>=<to_month><add_month" +
//         //                         "><sysdate>nowdate</sysdate>,
//         //                         -1</add_month></to_month></elseif><then><to_day>2022-04" +
//         //                         "-01</to_day>-<to_day>2022-03-01</to_day>+1</then><elseif><to_year>2022-03-01" +
//         //                         "</to_year><![CDATA[<]]><to_year><add_month><sysdate>nowdate</sysdate>," +
//         //                         "-1</add_month></to_year> and <to_year>2022-04-01</to_year>=<to_year><add_month" +
//         //                         "><sysdate>nowdate</sysdate>,-1</add_month></to_year> and " +
//         //                         "<to_month>2022-03-01</to_month>=<to_month><add_month><sysdate>nowdate</sysdate>," +
//         //                         "-1</add_month></to_month> and
//         //                         <to_month>2022-04-01</to_month><![CDATA[>]]><to_month" +
//         //                         "><add_month><sysdate>nowdate</sysdate>," +
//         //                         "-1</add_month></to_month></elseif><then><last_day><add_month><sysdate>nowdate" +
//         //                         "</sysdate>,-1</add_month></last_day>-<to_day>2022-03-01</to_day>+1</then><elseif" +
//         //                         "><to_year>2022-03-01</to_year><![CDATA[<]]><to_year><add_month><sysdate>nowdate" +
//         //                         "</sysdate>,-1</add_month></to_year> and " +
//         //                         "<to_year>2022-04-01</to_year>=<to_year><add_month><sysdate>nowdate</sysdate>," +
//         //                         "-1</add_month></to_year> and
//         //                         <to_month>2022-03-01</to_month><![CDATA[<]]><to_month" +
//         //                         "><add_month><sysdate>nowdate</sysdate>,-1</add_month></to_month> and " +
//         //                         "<to_month>2022-04-01</to_month>=<to_month><add_month><sysdate>nowdate</sysdate>," +
//         //                         "-1</add_month></to_month></elseif><then><to_day>2022-04-01</to_day></then><elseif" +
//         //                         "><to_year>2022-03-01</to_year><![CDATA[<]]><to_year><add_month><sysdate>nowdate" +
//         //                         "</sysdate>,-1</add_month></to_year> and " +
//         //                         "<to_year>2022-04-01</to_year>=<to_year><add_month><sysdate>nowdate</sysdate>," +
//         //                         "-1</add_month></to_year> and
//         //                         <to_month>2022-03-01</to_month><![CDATA[>]]><to_month" +
//         //                         "><add_month><sysdate>nowdate</sysdate>,-1</add_month></to_month> and " +
//         //                         "<to_month>2022-04-01</to_month><![CDATA[>]]><to_month><add_month><sysdate>nowdate" +
//         //                         "</sysdate>,-1</add_month></to_month></elseif><then><last_day><add_month><sysdate" +
//         //                         ">nowdate</sysdate>,-1</add_month></last_day></then><elseif><to_year>2022-03-01" +
//         //                         "</to_year><![CDATA[<]]><to_year><add_month><sysdate>nowdate</sysdate>," +
//         //                         "-1</add_month></to_year> and <to_year>2022-04-01</to_year>=<to_year><add_month" +
//         //                         "><sysdate>nowdate</sysdate>,-1</add_month></to_year> and " +
//         //                         "<to_month>2022-04-01</to_month><![CDATA[>]]><to_month><add_month><sysdate>nowdate" +
//         //                         "</sysdate>,-1</add_month></to_month></elseif><then><last_day><add_month><sysdate" +
//         //                         ">nowdate</sysdate>,-1</add_month></last_day></then><elseif><to_year>2022-03-01" +
//         //                         "</to_year><![CDATA[<]]><to_year><add_month><sysdate>nowdate</sysdate>," +
//         //                         "-1</add_month></to_year> and <to_year>2022-04-01</to_year>=<to_year><add_month" +
//         //                         "><sysdate>nowdate</sysdate>,-1</add_month></to_year> " +
//         //                         "and<to_month>2022-04-01</to_month>=<to_month><add_month><sysdate>nowdate</sysdate
//         //                         >," +
//         //                         "-1</add_month></to_month></elseif><then><to_day>2022-04-01</to_day></then><else>0" +
//         //                         "</else></data>");
//         // formulaList.add("<data><if>1c0212e3-ac13-4298-b833-da270c36bbd3=be54a20e-f986-4d5d-ab60-8bd822156665</if" +
//         //                         "><then><round>2296/31*0,0</round></then><else><round>2296/31*0*0.2," +
//         //                         "0</round></else></data>");
//         // formulaList.add("<data>0+0+0</data>");
//         // formulaList.add("<data><round><if>100=101</if><then>2510.11</then><else>200.52</else>,0</round></data>");
//         formulaList.add("<data><if>'923b780b-2396-45c3-8072-bb87983b76bb'==['923b780b-2396-45c3-8072-bb87983b76bb" +
//                                 "'，'80201892-308d-46b2-8dc9-9af533a74ac7'，'021c2157-dde0-4dd2-943b-c23bad4ea8e4']</if" +
//                                 "><then>0</then><else>20*0.005</else></data>");
//         Document document = XmlUtil.readXML(StringUtil.valueOf(formulaList.get(0)));
//
//         String doc = "";
//         doc = parseFormulaDoc(null, document, StringUtil.valueOf(formulaList.get(0)), "psnid", Boolean.FALSE);
//         System.out.println(doc);
//         // 创建多线程处理任务
//         // MultiThreadUtils< String > threadUtils = MultiThreadUtils.newInstance(0);
//         // // 辅助参数 加数
//         // Map< String,Object > params = new HashMap<>();
//         // params.put("addNum", 4);
//         //
//         // threadUtils.execute(formulaList, params, new IThreadTask< ThreadResultBean< Object >,String >()
//         // {
//         //     @Override public ThreadResultBean< Object > execute(String formulaStr, Map< ?,? > params)
//         //     {
//         //         boolean xmlDocument = isXmlDocument(StringUtil.valueOf(formulaStr));
//         //         if (xmlDocument)
//         //         {
//         //             System.out.println(params.get("threadName") + formulaStr);
//         //             Document document = XmlUtil.readXML(StringUtil.valueOf(formulaStr));
//         //             parseFormulaDoc(document);
//         //         }
//         //         return null;
//         //     }
//         // });
//     }
//
//     public String parseFormulaDoc(Document document, String formula_parse, Boolean isCheck)
//     { return parseFormulaDoc(null, document, formula_parse, isCheck); }
//
//     public static String parseFormulaDoc(Map< String,Object > pramSalaryDataMap, Document document,
//             String formula_parse, Boolean isCheck)
//     { return parseFormulaDoc(pramSalaryDataMap, document, formula_parse, null, isCheck); }
//
//     public static String parseFormulaDoc(Map< String,Object > pramSalaryDataMap, Document document,
//             String formulaParse, String pramformulaKey, Boolean isCheck)
//     {
//
//         // 获取根节点名称
//         String rootName = document.getDocumentElement().getTagName();
//         Element element = document.getDocumentElement();
//
//         return getInstance(pramSalaryDataMap, formulaParse, pramformulaKey).parseElement(element, isCheck);
//     }
//
//
//     /************************************************************* <br>
//      *
//      *说明: 分析xml文档<br>
//      *
//      * @Description   <br>
//      * @Date Created on 2021/9/29  12:54  <br>
//      * @Param [element] <br>
//      * @return java.lang.String  <br>
//      * @Author LIBENCHENG
//      * @version 1.0 <br>
//      ************************************************************* <br>
//      */
//     public String parseElement(Element element, Boolean isCheck)
//     {
//         String calcResult = "";
//         NodeList nodeList = element.getChildNodes();
//         calcResult = parseNode(element.getFirstChild(), isCheck);
//         // for (int temp = 0; temp < nodeList.getLength(); temp++)
//         // {
//         //     Node childNode = nodeList.item(temp);
//         //     // if (Node.TEXT_NODE == childNode.getNodeType())
//         //     // { calcStr += childNode.getNodeValue(); }
//         //
//         //     // 过滤then，elseif，else及其子标签和内容
//         //     if (chenkUnEffective(childNode))
//         //     { calcStr = parseNode(childNode, isCheck); }
//         // }
//         //  当标签内容的类型为text，它的上级标签，是为then 或else ，用于计算
//         if (FunEnumUtil.getFunNames().contains(element.getNodeName())
//                 || PubEnvUtil.equals(calcResult, FunTimeEnum.NOW_DATE.getFunName()))
//         { calcResult = calcResult(element.getNodeName(), calcResult, isCheck); }
//
//         if (checkAlgorithm(calcResult, isCheck))
//         { calcResult = calcResult(element.getNodeName(), calcResult, isCheck); }
//         //最终计算结果，进行非数字校验
//         checkAssert(!RegularUtil.regNFPNum.matcher(calcResult).matches(), ISalaryMsg.FORMULA_CHECK_ERROR);
//
//         return calcResult;
//     }
//
//     /************************************************************* <br>
//      *
//      *说明:分析xml文档节点节点 <br>
//      *
//      * @Description   <br>
//      * @Date Created on 2021/9/29  12:32  <br>
//      * @Param [node] <br>
//      * @return java.lang.String  <br>
//      * @Author LIBENCHENG
//      * @version 1.0 <br>
//      ************************************************************* <br>
//      */
//     private String parseNode(Node node, Boolean isCheck)
//     {
//         String contentStr = "";
//         if (!PubEnvUtil.isEmptyObj(node))
//         {
//             if (FunOhterEnum.IF.getFunName().equals(node.getNodeName()))
//             { contentStr += (parseIfFun(node, contentStr, isCheck)); }
//             else
//             {
//                 if (XmlUtil.isElement(node))
//                 {
//                     Node firstChildTemp = node.getFirstChild();
//                     // 查找下一個标签或者内容   <这里有big>
//                     if (PubEnvUtil.equals(ISalaryCons.DATA, node.getNodeName())
//                             && PubEnvUtil.equals(FunOhterEnum.IF.getFunName(), firstChildTemp.getNodeName()))
//                     {
//                         contentStr = getOperationStr(parseNode(firstChildTemp, isCheck),
//                                                      parseNode(node.getNextSibling(), isCheck));
//                     }
//                     else { contentStr = parseNode(firstChildTemp, isCheck); }
//                 }
//                 else
//                 {
//                     if (Node.TEXT_NODE == node.getNodeType())
//                     {
//                         contentStr = getOperationStr(node.getNodeValue()
//                                                          .trim(), parseNode(node.getNextSibling(), isCheck));
//                     }
//                     if (Node.CDATA_SECTION_NODE == node.getNodeType())
//                     {
//                         String nodeValue = node.getNodeValue();
//                         // 校验>,<,=,==,!=,<>
//                         // checkCompareSymbol(nodeValue);
//                         checkAssert(!Arrays.asList(ISalaryCons.OPERATE_COMPARE)
//                                            .contains(nodeValue.trim()), ISalaryMsg.FORMULA_OPERATE_ERROR);
//                         contentStr = getOperationStr(nodeValue, parseNode(node.getNextSibling(), isCheck));
//                     }
//                 }
//             }
//             //  当标签内容的类型为text，它的上级标签，是为then 或else ，用于计算
//             if (FunEnumUtil.getComputeFunNames().contains(node.getNodeName()))
//             {
//                 contentStr = getOperationStr(calcResult(node.getNodeName(), contentStr, isCheck),
//                                              parseNode(node.getNextSibling(), isCheck));
//             }
//         }
//         return contentStr;
//     }
//
//     /************************************************************* <br>
//      *
//      *说明:处理 if elseif else 函数 <br>
//      *
//      * @Description   <br>
//      * @Date Created on 2021/9/29  11:04  <br>
//      * @Param [childNode, contentStr] <br>
//      * @return java.lang.String  <br>
//      * @Author LIBENCHENG
//      * @version 1.0 <br>
//      ************************************************************* <br>
//      */
//     public String parseIfFun(Node childNode, String contentStr, Boolean isCheck)
//     {
//         // chexkIfFun(childNode.getParentNode(), isCheck);
//         return exeParseIfFun(childNode, contentStr, isCheck);
//     }
//
//     public String exeParseIfFun(Node childNode, String contentStr, Boolean isCheck)
//     {
//         if (PubEnvUtil.equals(IPubEvnCons.FALSE, contentStr)
//                 || PubEnvUtil.equals(IPubEvnCons.TRUE, contentStr))
//         { contentStr = parseNode(childNode.getFirstChild(), isCheck); }
//         else { contentStr = parseNode(childNode.getFirstChild(), isCheck); }
//         if (Arrays.asList(FunOhterEnum.ELSE_IF.getFunName(), FunOhterEnum.IF.getFunName())
//                   .contains(childNode.getNodeName()))
//         { contentStr = calcResult(FunOhterEnum.IF.getFunName(), contentStr, isCheck); }
//         Node nextSibling = childNode.getNextSibling();
//         // if()==true  else if()==true
//         if (PubEnvUtil.equals(PubEnvUtil.TRUE, contentStr))
//         { contentStr = parseIfFun(nextSibling, contentStr, isCheck); }
//         // else if()==false ,if()==false
//         else if (PubEnvUtil.equals(IPubEvnCons.FALSE, contentStr))
//         {
//             checkThenNode(nextSibling, isCheck);
//             contentStr = parseIfFun(nextSibling.getNextSibling(), contentStr, isCheck);
//         }
//         else { }
//
//         return contentStr;
//     }
//
//     /************************************************************* <br>
//      *
//      *说明: 递归校验 ifelse函数体内容<br>
//      *
//      * @Description   <br>
//      * @Date Created on 2022/3/11  9:59  <br>
//      * @param childNode
//      * @param isCheck <br>
//      * @return void  <br>
//      * @Author LIBENCHENG
//      * @version 1.0 <br>
//      ************************************************************* <br>
//      */
//     public void chexkIfFun(Node childNode, Boolean isCheck)
//     {
//         if (isCheck && !PubEnvUtil.isEmptyObj(childNode))
//         {
//             AtomicReference< Boolean > isChildNode = new AtomicReference<>(Boolean.FALSE);
//             Arrays.stream(ISalaryCons.IF_EFFECTIVE_FUN)
//                   .forEach(funStr ->
//                            {
//                                if (PubEnvUtil.equals(funStr, childNode.getNodeName()))
//                                { isChildNode.set(Boolean.TRUE); }
//                            });
//             NodeList childNodes = childNode.getChildNodes();
//             if (PubEnvUtil.equals(ISalaryCons.DATA, childNode.getNodeName()) || isChildNode.get())
//             {
//                 for (int temp = 0; temp < childNodes.getLength(); temp++)
//                 { chexkIfFun(childNodes.item(temp), isCheck); }
//             }
//             else
//             {
//                 //其它页签校验
//                 if (!PubEnvUtil.equals(IPubEvnCons.THREE, childNode.getNodeType()))
//                 { calcResult(childNode.getNodeName(), childNode.getChildNodes().item(0).getNodeValue(), isCheck); }
//             }
//         }
//     }
//
//
//     /************************************************************* <br>
//      *
//      *说明: if 函数校验then标签的前后标签,then相邻标签是if或elseif或else标签<br>
//      *
//      * @Description   <br>
//      * @Date Created on 2021/11/11  10:57  <br>
//      * @param nextSibling <br>
//      * @return void  <br>
//      * @Author LIBENCHENG
//      * @version 1.0 <br>
//      ************************************************************* <br>
//      */
//     void checkThenNode(Node nextSibling, Boolean isCheck)
//     {
//         String thenNextName = getThenNodeName(nextSibling, Boolean.TRUE, isCheck);
//         String thenPreviousName = getThenNodeName(nextSibling, Boolean.FALSE, isCheck);
//         checkAssert((!(PubEnvUtil.equals(FunOhterEnum.ELSE.getFunName(), thenNextName)
//                             || PubEnvUtil.equals(FunOhterEnum.ELSE_IF.getFunName(), thenNextName)))
//                             || (!(PubEnvUtil.equals(FunOhterEnum.IF.getFunName(), thenPreviousName)
//                             || PubEnvUtil.equals(FunOhterEnum.ELSE_IF.getFunName(), thenPreviousName))),
//                     ISalaryMsg.FORMULA_THEN_ERROR);
//     }
//
//     String getThenNodeName(Node nextSibling, Boolean isNext, Boolean isCheck)
//     {
//         String nodeName = nextSibling.getNodeName();
//         if (isNext)
//         {
//             Node nextNode = nextSibling.getNextSibling();
//             if (PubEnvUtil.isEmptyObj(nextNode))
//             { nextNode = nextSibling; }
//             else
//             { nodeName = nextNode.getNodeName(); }
//             // then前面标签是if或elseif或else标签
//             if (PubEnvUtil.equals(IPubEvnCons.THREE, nextNode.getNodeType()))
//             { nodeName = getThenNodeName(nextNode, isNext, isCheck); }
//         }
//         else
//         {
//             Node nextNode = nextSibling.getPreviousSibling();
//             nodeName = nextNode.getNodeName();
//             // then前面标签是if或elseif或else标签
//             if (PubEnvUtil.equals(IPubEvnCons.THREE, nextNode.getNodeType()))
//             { nodeName = getThenNodeName(nextNode, isNext, isCheck); }
//         }
//
//         return nodeName;
//     }
//
//     /************************************************************* <br>
//      *
//      *说明: 校验公式中的操作符是不是有效 <br>
//      *
//      * @Description   <br>
//      * @Date Created on 2021/9/29  12:02  <br>
//      * @Param [nodeValue1, nodeValue2] <br>
//      * @return java.lang.String  <br>
//      * @Author LIBENCHENG
//      * @version 1.0 <br>
//      ************************************************************* <br>
//      */
//     public String getOperationStr(String nodeValue1, String nodeValue2)
//     {
//         if (!PubEnvUtil.isEmpty(nodeValue1) && !PubEnvUtil.isEmpty(nodeValue2))
//         {
//             AtomicReference< Boolean > isEffective = new AtomicReference<>(Boolean.FALSE);
//             Arrays.asList(ISalaryCons.OPT_OPERATOR)
//                   .stream()
//                   .forEach(option ->
//                            {
//                                if (nodeValue1.endsWith(option)) { isEffective.set(Boolean.TRUE); }
//                                if (nodeValue2.contains(option)) { isEffective.set(Boolean.TRUE); }
//                            });
//
//             checkAssert(!isEffective.get(), ISalaryMsg.FORMULA_OPERATE_ERROR);
//         }
//
//         return StringUtil.valueOfEmpty(nodeValue1) + StringUtil.valueOfEmpty(nodeValue2);
//     }
//
//     /************************************************************* <br>
//      *
//      *说明: 四则运算计算《核心方法》<br>
//      *
//      * @Description   <br>
//      * @Date Created on 2021/11/1  16:00  <br>
//      * @param nodeName xml节点，公式函数
//      * @param nodeValue xml节点内容
//      * @param isCheck 是否公式校验<br>
//      * @return java.lang.String  <br>
//      * @Author LIBENCHENG
//      * @version 1.0 <br>
//      ************************************************************* <br>
//      */
//     private String calcResult(String nodeName, String nodeValue, Boolean isCheck)
//     {
//         try
//         {
//             nodeValue = calcBefore(nodeName, nodeValue, isCheck);
//             // 时间相关的函数
//             if (FunTimeEnum.getFunNames().contains(nodeName))
//             { nodeValue = funTime(nodeName, nodeValue, isCheck); }
//             else
//             {
//                 switch (nodeName)
//                 {
//                     // 算术逻辑单元
//                     case ISalaryCons.ALU:
//                         checkFourArithmetic(nodeValue, isCheck);
//                         nodeValue = CalculatorHelper.convStrOfZero(nodeValue);
//                         break;
//                     case ISalaryCons.GETSUBVALUE:
//                         nodeValue = SalaryCalcUtil.getSubValue(salaryDataMap, formulaKey, nodeValue, isCheck);
//                         break;
//                     case ISalaryCons.ABS:
//                         checkFourArithmetic(nodeValue, isCheck);
//                         //  Math.abs(return d <= 0.0D) ? 0.0D - d : d )
//                         Double abs = Math.abs(PubEnvUtil.parseDouble(CalculatorHelper.convStrOfZero(nodeValue)));
//                         nodeValue = valueOfZero(abs);
//                         break;
//                     case ISalaryCons.CEIL:
//                         checkFourArithmetic(nodeValue, isCheck);
//                         Double ceil = Math.ceil(PubEnvUtil.parseDouble(CalculatorHelper.convStrOfZero(nodeValue)));
//                         nodeValue = valueOfZero(ceil);
//                         break;
//                     case ISalaryCons.FLOOR:
//                         checkFourArithmetic(nodeValue, isCheck);
//                         Double floor = Math.floor(PubEnvUtil.parseDouble(CalculatorHelper.convStrOfZero(nodeValue)));
//                         nodeValue = valueOfZero(floor);
//                         break;
//                     case ISalaryCons.ROUND:
//                         nodeValue = funRound(nodeValue, isCheck);
//                         break;
//                     case ISalaryCons.SUBSTRING:
//                         nodeValue = funSubString(nodeValue);
//                         break;
//                     case ISalaryCons.ISNULL:
//                         nodeValue = funIsNull(nodeValue, isCheck);
//                         break;
//                     case ISalaryCons.IF:
//                     {
//                         String regex = "if\\s*\\((.*|\\s*)*}\\s*else\\s*\\{(.*|\\s*)*}";
//                         nodeValue = StringUtil.valueOfEmpty(functionIF(nodeValue, isCheck));
//                         // 包含and 和 OR
//                         if (nodeValue.contains(IPubCons.AND) || nodeValue.contains(IPubCons.OR))
//                         { nodeValue = StringUtil.valueOfEmpty(parseNodeValue(nodeValue, isCheck)); }
//                         // 判断false，true
//                         if (!(nodeValue.contains(IPubCons.FALSE) || nodeValue.contains(IPubCons.TRUE)))
//                         { nodeValue = StringUtil.valueOfEmpty(parseCompareSymbol(nodeValue, isCheck)); }
//                         break;
//                     }
//                     default:
//                         nodeValue = CalculatorHelper.convStrOfZero(nodeValue);
//                 }
//             }
//         }
//         catch (Exception e)
//         {
//             throw new RuntimeException(e);
//         }
//
//         return nodeValue;
//     }
//
//
//     /************************************************************* <br>
//      *
//      *说明: r如果是校验设置一些默认值<br>
//      *
//      * @Description   <br>
//      * @Date Created on 2021/4/3  0:11  <br>
//      * @param nodeName
//      * @param nodeValue
//      * @param isCheck <br>
//      * @return java.lang.String  <br>
//      * @Author LIBENCHENG
//      * @version 1.0 <br>
//      ************************************************************* <br>
//      */
//     private String calcBefore(String nodeName, String nodeValue, Boolean isCheck)
//     {
//         if (isCheck && Arrays.asList(FunMathEnum.ABS.getFunName(),
//                                      FunMathEnum.CEIL.getFunName(),
//                                      FunMathEnum.FLOOR.getFunName(),
//                                      FunMathEnum.ROUND.getFunName(),
//                                      FunOhterEnum.SUBSTRING.getFunName())
//                              .contains(nodeName))
//         {
//             if (PubEnvUtil.equals(FunMathEnum.ROUND.getFunName(), nodeName))
//             {
//                 String[] rounds = nodeValue.split(PubEnvUtil.COMMA);
//                 if (PubEnvUtil.getSize(rounds) < 2)
//                 { throw new RuntimeException(formatErrStr(nodeValue + ISalaryMsg.FORMULA_ROUND_ERROR)); }
//                 checkFourArithmetic(rounds[0], isCheck);
//                 nodeValue = PubEnvUtil.ZERO + PubEnvUtil.COMMA + rounds[1];
//             }
//             else if (PubEnvUtil.equals(FunOhterEnum.SUBSTRING.getFunName(), nodeName))
//             {
//                 String[] subStrs = nodeValue.split(IPubEvnCons.COMMA);
//                 if (PubEnvUtil.getSize(subStrs) == 3)
//                 { nodeValue = "00000000000000000000," + subStrs[1] + "," + subStrs[2]; }
//                 if (PubEnvUtil.getSize(subStrs) == 2)
//                 { nodeValue = "00000000000000000000," + subStrs[1]; }
//             }
//             else
//             {
//                 checkFourArithmetic(nodeValue, isCheck);
//                 nodeValue = PubEnvUtil.ZERO;
//             }
//         }
//         if (isCheck)
//         { return nodeValue; }
//
//         return nodeValue.replace("+-", IPubEvnCons.DASH)
//                         .replace("--", IPubEvnCons.PLUS)
//                         .replace("++", IPubEvnCons.PLUS);
//     }
//
//     /************************************************************* <br>
//      *
//      *说明:处理【round】 <br>
//      *
//      * @Description   <br>
//      * @Date Created on 2021/9/29  13:50  <br>
//      * @Param [nodeValue] <br>
//      * @return java.lang.String  <br>
//      * @Author LIBENCHENG
//      * @version 1.0 <br>
//      ************************************************************* <br>
//      */
//     private String funRound(String nodeValue, Boolean isCheck)
//     {
//         String[] strs = nodeValue.replace(FunMathEnum.ROUND.getFunName(), IPubEvnCons.EMPTY).split(IPubCons.COMMA);
//         if (PubEnvUtil.isEmpty(nodeValue)) { return PubEnvUtil.ZERO; }
//         String calcStr = strs[0];
//         checkFourArithmetic(calcStr, isCheck);
//         String digitStr = PubEnvUtil.getSize(strs) > 1 ? strs[1] : PubEnvUtil.ZERO;
//         if (nodeValue.contains(IPubEvnCons.ASTERISK) || nodeValue.contains(IPubEvnCons.SLASH)
//                 || nodeValue.contains(IPubEvnCons.PLUS) || nodeValue.contains(IPubEvnCons.DASH))
//         { calcStr = CalculatorHelper.convStrOfZero(calcStr); }
//
//         if (!NumberUtil.isNumber(calcStr))
//         { throw new RuntimeException(formatErrStr(nodeValue + ISalaryMsg.FORMULA_ROUND_ERROR)); }
//         int places = Integer.parseInt(NumberUtil.isInteger(digitStr) ? digitStr : PubEnvUtil.ZERO);
//         // 数据保留小数点4位
//         if (places > 4)
//         { throw new RuntimeException(formatErrStr(nodeValue + ISalaryMsg.FORMULA_PLACES_ERROR)); }
//
//         nodeValue = StringUtil.valueOfZero(NumberUtil.round(
//                 PubEnvUtil.parseDouble(CalculatorHelper.convStrOfZero(calcStr)),
//                 Integer.parseInt(StringUtil.valueOfZero(
//                         PubEnvUtil.getSize(strs) < 2 ? IPubEvnCons.ZERO : (places)))));
//
//         return nodeValue;
//     }
//
//     /************************************************************* <br>
//      *
//      *说明: 处理isnull函数<br>
//      *
//      * @Description   <br>
//      * @Date Created on 2021/9/29  13:09  <br>
//      * @Param [nodeValue] <br>
//      * @return java.lang.String  <br>
//      * @Author LIBENCHENG
//      * @version 1.0 <br>
//      ************************************************************* <br>
//      */
//     private String funIsNull(String nodeValue, Boolean isCheck)
//     {
//         String[] strs = nodeValue.replace(ISalaryCons.ISNULL, IPubEvnCons.EMPTY).split(IPubCons.COMMA);
//
//         if (PubEnvUtil.getSize(strs) < 2
//                 || (!NumberUtil.isNumber(IPubEvnCons.NULL.equals(strs[0]) ? IPubEvnCons.ZERO : strs[0]))
//                 || !NumberUtil.isNumber(strs[1]))
//         { throw new RuntimeException(formatErrStr(nodeValue + ISalaryMsg.FORMULA_NUM_ERROR)); }
//
//         if (PubEnvUtil.getSize(strs) == 2)
//         {
//             nodeValue = Double.valueOf(CalculatorHelper.conversionStr(strs[0])).isNaN()
//                     ? StringUtil.valueOf(CalculatorHelper.conversionStr(strs[1]))
//                     : StringUtil.valueOf(CalculatorHelper.conversionStr(strs[0]));
//         }
//         else
//         { nodeValue = StringUtil.valueOfZero(nodeValue); }
//         return nodeValue;
//     }
//
//     /************************************************************* <br>
//      *
//      *说明:处理截取字符串函数 <br>
//      *
//      * @Description   <br>
//      * @Date Created on 2021/9/29  13:08  <br>
//      * @Param [nodeValue] <br>
//      * @return java.lang.String  <br>
//      * @Author LIBENCHENG
//      * @version 1.0 <br>
//      ************************************************************* <br>
//      */
//     private String funSubString(String nodeValue)
//     {
//         // <substring>-5000,0,3</substring>
//         if (PubEnvUtil.isEmpty(nodeValue))
//         { return PubEnvUtil.ZERO; }
//         String[] subStrs = nodeValue.split(IPubEvnCons.COMMA);
//         String value = subStrs[0];
//         if (PubEnvUtil.equals(PubEnvUtil.ZERO, value))
//         { return PubEnvUtil.ZERO; }
//         // substring(v,i,j)
//         if (PubEnvUtil.getSize(subStrs) == 3)
//         {
//             checkAssert(!NumberUtil.isInteger(subStrs[1]) || !NumberUtil.isInteger(subStrs[2])
//                     , nodeValue + ISalaryMsg.FORMULA_SPLIT_ERROR);
//             int start = NumberUtil.parseInt(subStrs[1]);
//             int end = NumberUtil.parseInt(subStrs[2]);
//             checkAssert(end > 36, ISalaryMsg.FORMULA_SPLIT_ERROR);
//             end = (Math.min(NumberUtil.parseInt(subStrs[2]), value.length()));
//             checkAssert(start < 0 || end < 0, nodeValue + ISalaryMsg.FORMULA_SPLIT_ERROR);
//             if (start > end)
//             { start = 0; }
//             // { throw new RuntimeException(formatErrStr(start + end + ISalaryMsg.FORMULA_SUB_ERROR)); }
//
//             nodeValue = value.substring(start, end);
//         }
//         // substring(v,i)
//         if (PubEnvUtil.getSize(subStrs) == 2)
//         {
//             checkAssert(!NumberUtil.isInteger(subStrs[1]), nodeValue + ISalaryMsg.FORMULA_SPLIT_ERROR);
//             int end = NumberUtil.parseInt(subStrs[1]);
//             // checkAssert(i > subStrs[0].length(), nodeValue + ISalaryMsg.FORMULA_SUBEND_ERROR);
//             checkAssert(end > 36, nodeValue + ISalaryMsg.FORMULA_SUBEND2_ERROR);
//             int start = subStrs[0].length() - Math.abs(end);
//             checkAssert(end < 0 && start < 0, nodeValue + ISalaryMsg.FORMULA_SUBSTART_ERROR);
//             if (end < 0)
//             { nodeValue = value.substring(start, Math.max(NumberUtil.parseInt(subStrs[1]), value.length())); }
//             else if (end > 0)
//             { nodeValue = value.substring(0, Math.min(NumberUtil.parseInt(subStrs[1]), value.length())); }
//             else { nodeValue = StringUtil.valueOfZero(nodeValue); }
//
//         }
//         // substring(v)
//         if (PubEnvUtil.getSize(subStrs) < 2)
//         { nodeValue = StringUtil.valueOfZero(nodeValue); }
//
//         return nodeValue;
//     }
//
//     /************************************************************* <br>
//      *
//      *说明: 获取yyyy-MM-dd hh:mm:ss格式的时间串<br>
//      *
//      * @Description   <br>
//      * @Date Created on 2021/11/3  19:59  <br>
//      * @param funContent 函数内容
//      * @param isCheck 是否校验<br>
//      * @return java.lang.String  <br>
//      * @Author LIBENCHENG
//      * @version 1.0 <br>
//      ************************************************************* <br>
//      */
//     String getDateTime(String funContent, Boolean isCheck)
//     {
//
//         AtomicReference< Boolean > isEffective = new AtomicReference<>(Boolean.FALSE);
//         String finalFunContent = funContent;
//         Arrays.asList(ISalaryCons.ITEM_PREFIX_PSN,
//                       ISalaryCons.ITEM_PREFIX_JOB,
//                       ISalaryCons.ITEM_PREFIX_A)
//               .stream()
//               .forEach(option ->
//                        {
//                            if (finalFunContent.startsWith(option)) { isEffective.set(Boolean.TRUE); }
//                        });
//
//         if ((isEffective.get() && isCheck) || PubEnvUtil.equals(ISalaryCons.NOW_DATE, funContent))
//         { funContent = DateUtilbc.currentDateTime(); }
//
//         if (!DateUtilbc.isValidDateTime(funContent))
//         {
//             if (PubEnvUtil.equals(PubEnvUtil.ZERO, funContent))
//             { return funContent; }
//             throw new RuntimeException(formatErrStr(String.format(ISalaryMsg.FORMULA_DATE_ERROR, funContent)));
//         }
//
//         return StringUtil.valueOfZero(new DateTime(funContent));
//     }
//
//     /************************************************************* <br>
//      *
//      *说明: 解析时间相关的函数<br>
//      *    目前支持的日期格式：yyyy-MM-dd hh:mm:ss，yyyy/MM/dd hh:mm:ss，yyyyMMddhhmmss
//      * @Description   <br>
//      * @Date Created on 2021/11/1  21:55  <br>
//      * @param funName 函数名
//      * @param funContent 函数内容：yyyymmdd/yyyymmdd,yyyymmdd,yyyymmdd/yyyymmdd,i
//      * @param isCheck 是否校验<br>
//      * @return java.lang.String  <br>
//      * @Author LIBENCHENG
//      * @version 1.0 <br>
//      ************************************************************* <br>
//      */
//     private String funTime(String funName, String funContent, Boolean isCheck) throws ParseException
//     {
//         if (PubEnvUtil.isEmpty(funContent))
//         { return PubEnvUtil.ZERO; }
//         String[] strs = funContent.split(PubEnvUtil.COMMA);
//         if (PubEnvUtil.getSize(strs) == 1)
//         {
//             if (funName.startsWith(ISalaryCons.TO_)
//                     || PubEnvUtil.equals(FunTimeEnum.LAST_DAY.getFunName(), funName)
//                     || PubEnvUtil.equals(FunTimeEnum.BEGIN_DATE.getFunName(), funName)
//                     || PubEnvUtil.equals(FunTimeEnum.SYS_DATE.getFunName(), funName))
//             {
//                 if (PubEnvUtil.equals(FunTimeEnum.TO_DATE.getFunName(), funName))
//                 {
//                     funContent = StringUtil.valueOfDefault(DateUtilbc.parseDate(funContent, "YYYY-MM-DD hh:mm:ss")
//                             , "1970-01-01 00:00:00");
//                 }
//                 else { funContent = funTimeStr(funName, getDateTime(funContent.trim(), isCheck)); }
//             }
//             else { throw new RuntimeException(formatErrStr(ISalaryMsg.FORMULA_UNSUPPORT_DATE_ERROR)); }
//         }
//         else if (PubEnvUtil.getSize(strs) == 2)
//         {
//             String dataStr = strs[0].trim();
//             String addStr = strs[1].trim();
//             // 获取指定时间格式的时间串
//             if (PubEnvUtil.equals(FunTimeEnum.TO_DATE.getFunName(), funName))
//             { funContent = StringUtil.valueOfDefault(DateUtilbc.parseDate(dataStr, addStr), "1970-01-01 00:00:00"); }
//             // 指定时间的相加减，单位年/月/天
//             else if (funName.startsWith(ISalaryCons.ADD_))
//             {
//                 if (!PubEnvUtil.isCalcNumber(addStr))
//                 { throw new RuntimeException(formatErrStr(ISalaryMsg.FORMULA_UNSUPPORT_DATE_ERROR)); }
//                 funContent = funTimeAdd(funName, getDateTime(dataStr, isCheck), Integer.parseInt(addStr));
//             }
//             // 指定时间date1和date2的时间差-单位年/月/天
//             else if (funName.startsWith(ISalaryCons.BETWEEN_))
//             { funContent = funTimeBetween(funName, getDateTime(dataStr, isCheck), getDateTime(addStr, isCheck)); }
//             else { throw new RuntimeException(formatErrStr(ISalaryMsg.FORMULA_UNSUPPORT_DATE_ERROR)); }
//         }
//         else if (PubEnvUtil.getSize(strs) == 3)
//         {
//             // 判断是否在某个时间段内
//             if (PubEnvUtil.equals(ISalaryCons.BETWEEN_DATE, funName))
//             {
//                 funContent =
//                         StringUtil.valueOfZero(funDateBetween(strs[0].trim(), strs[1].trim()
//                                 , strs[2].trim(), isCheck));
//             }
//             else { throw new RuntimeException(formatErrStr(ISalaryMsg.FORMULA_UNSUPPORT_DATE_ERROR)); }
//         }
//         else { throw new RuntimeException(formatErrStr(ISalaryMsg.FORMULA_UNSUPPORT_DATE_ERROR)); }
//
//         return funContent;
//     }
//
//
//     /************************************************************* <br>
//      *
//      *说明: 获取指定时间的yyyy,mm,dd,minday,maxday<br>
//      *
//      * @Description   <br>
//      * @Date Created on 2021/11/1  21:46  <br>
//      * @param funName 函数
//      * @param dateTime 指定的时间串
//      * @return java.lang.String  年或月或天，第一天，最后一天<br>
//      * @Author LIBENCHENG
//      * @version 1.0 <br>
//      ************************************************************* <br>
//      */
//     private String funTimeStr(String funName, String dateTime) throws ParseException
//     {
//         if (PubEnvUtil.equals(PubEnvUtil.ZERO, dateTime)) { return dateTime; }
//         switch (funName)
//         {
//             case ISalaryCons.TO_YEAR:
//                 dateTime = StringUtil.valueOfZero(DateTime.of(new DateTime(dateTime)).year());
//                 break;
//             case ISalaryCons.TO_MONTH:
//                 dateTime = StringUtil.valueOfZero(DateTime.of(new DateTime(dateTime)).month() + 1);
//                 break;
//             case ISalaryCons.TO_DAY:
//                 dateTime = StringUtil.valueOfZero(DateUtil.dayOfMonth(new DateTime(dateTime)));
//                 break;
//             case ISalaryCons.BEGIN_DATE:
//                 dateTime = StringUtil.valueOfZero(DateUtil.dayOfMonth(DateUtilbc.beginDateMonth(dateTime)));
//                 break;
//             case ISalaryCons.LAST_DAY:
//                 dateTime = StringUtil.valueOfZero(DateUtil.dayOfMonth(DateUtilbc.endDateMonth(dateTime)));
//                 break;
//             case ISalaryCons.SYS_DATE:
//                 // yyyy-MM-dd hh:mm:ss
//                 dateTime = DateUtilbc.currentDateTime();
//                 // yyyy-MM-dd
//                 // datetime = DateUtilbc.currentDate();
//                 break;
//             default:
//                 throw new RuntimeException(formatErrStr(ISalaryMsg.FORMULA_UNSUPPORT_DATE_ERROR));
//         }
//         return dateTime;
//     }
//
//     /************************************************************* <br>
//      *
//      *说明: 指定时间的相加减，单位年/月/天<br>
//      *
//      * @Description   <br>
//      * @Date Created on 2021/11/1  21:40  <br>
//      * @param funName   函数
//      * @param dateTime 时间
//      * @param addValue 相加的数据，正数表示时间相加，负数表示时间相减<br>
//      * @return java.lang.String  新的时间 <br>
//      * @Author LIBENCHENG
//      * @version 1.0 <br>
//      ************************************************************* <br>
//      */
//     private String funTimeAdd(String funName, String dateTime, Integer addValue) throws ParseException
//     {
//         if (PubEnvUtil.equals(PubEnvUtil.ZERO, dateTime)) { return dateTime; }
//         Date date = new DateTime();
//         switch (funName)
//         {
//             case ISalaryCons.ADD_YEAR:
//                 date = DateUtilbc.year(new DateTime(dateTime), addValue);
//                 break;
//             case ISalaryCons.ADD_MONTH:
//                 date = DateUtilbc.month(new DateTime(dateTime), addValue);
//                 break;
//             case ISalaryCons.ADD_DAY:
//                 date = DateUtilbc.day(new DateTime(dateTime), addValue);
//                 break;
//             case ISalaryCons.ADD_HOUR:
//                 date = DateUtilbc.hour(new DateTime(dateTime), addValue);
//                 break;
//             case ISalaryCons.ADD_MINUTE:
//                 date = DateUtilbc.minute(new DateTime(dateTime), addValue);
//                 break;
//             default:
//                 throw new RuntimeException(formatErrStr(ISalaryMsg.FORMULA_UNSUPPORT_DATE_ERROR));
//         }
//
//         return DateUtilbc.dateTime(date);
//     }
//
//     /************************************************************* <br>
//      *
//      *说明: 指定时间date1和date2的时间差-单位年/月/天<br>
//      *
//      * @Description   <br>
//      * @Date Created on 2021/11/1  21:39  <br>
//      * @param funName     函数
//      * @param startTime   开始时间
//      * @param endTime  结束时间<br>
//      * @return java.lang.String  时间差-单位年/月/天<br>
//      * @Author LIBENCHENG
//      * @version 1.0 <br>
//      ************************************************************* <br>
//      */
//     private String funTimeBetween(String funName, String startTime, String endTime) throws ParseException
//     {
//         if (PubEnvUtil.equals(PubEnvUtil.ZERO, startTime)
//                 || PubEnvUtil.equals(PubEnvUtil.ZERO, endTime))
//         { return PubEnvUtil.ZERO; }
//         Calendar cal = Calendar.getInstance();
//         cal.setTime(new DateTime(startTime));
//         LocalDateTime startDate = LocalDateTime.of(
//                 LocalDate.of(cal.get(Calendar.YEAR), cal.get(Calendar.MONTH), cal.get(Calendar.DATE)),
//                 LocalTime.of(cal.get(Calendar.HOUR), cal.get(Calendar.MINUTE), cal.get(Calendar.SECOND)));
//
//         cal = Calendar.getInstance();
//         cal.setTime(new DateTime(endTime));
//         LocalDateTime endDate = LocalDateTime.of(
//                 LocalDate.of(cal.get(Calendar.YEAR), cal.get(Calendar.MONTH), cal.get(Calendar.DATE)),
//                 LocalTime.of(cal.get(Calendar.HOUR), cal.get(Calendar.MINUTE), cal.get(Calendar.SECOND)));
//
//         long between = 0L;
//         switch (funName)
//         {
//             case ISalaryCons.BETWEEN_YEAR:
//                 between = ChronoUnit.YEARS.between(startDate, endDate);
//                 break;
//             case ISalaryCons.BETWEEN_MONTH:
//                 between = ChronoUnit.MONTHS.between(startDate, endDate);
//                 break;
//             case ISalaryCons.BETWEEN_DAY:
//                 // Duration,ChronoUnit,Period 【JDK8 API】
//                 between = ChronoUnit.DAYS.between(startDate, endDate);
//                 break;
//             case ISalaryCons.BETWEEN_HOURS:
//                 between = ChronoUnit.HOURS.between(startDate, endDate);
//                 break;
//             case ISalaryCons.BETWEEN_MINUTES:
//                 between = ChronoUnit.MINUTES.between(startDate, endDate);
//                 break;
//             case ISalaryCons.BETWEEN_SECONDS:
//                 between = ChronoUnit.SECONDS.between(startDate, endDate);
//                 break;
//             default:
//                 throw new RuntimeException(formatErrStr(ISalaryMsg.FORMULA_UNSUPPORT_DATE_ERROR));
//         }
//
//         return StringUtil.valueOfZero(Math.abs(between));
//     }
//
//     /************************************************************* <br>
//      *
//      *说明: 判断是否在某个时间段内<br>
//      *
//      * @Description   <br>
//      * @Date Created on 2021/11/1  23:31  <br>
//      * @param startTime
//      * @param endTime
//      * @param time <br>
//      * @return java.lang.Boolean  <br>
//      * @Author LIBENCHENG
//      * @version 1.0 <br>
//      ************************************************************* <br>
//      */
//     private Boolean funDateBetween(String startTime, String endTime, String time, Boolean isCheck) throws
//             ParseException
//     {
//         startTime = getDateTime(startTime, isCheck);
//         endTime = getDateTime(endTime, isCheck);
//         time = getDateTime(time, isCheck);
//         if (PubEnvUtil.equals(PubEnvUtil.ZERO, time)
//                 || PubEnvUtil.equals(PubEnvUtil.ZERO, startTime)
//                 || PubEnvUtil.equals(PubEnvUtil.ZERO, endTime))
//         { return Boolean.FALSE; }
//
//         return DateUtilbc.between(startTime, endTime, new DateTime(time));
//     }
//
//     /************************************************************* <br>
//      *
//      *说明:将对应的 函数替换成xml标签  <br>
//      *
//      * @Description   <br>
//      * @Date Created on 2021/9/30  14:54  <br>
//      * @Param [formulaStr] <br>
//      * @return java.lang.String  <br>
//      * @Author LIBENCHENG
//      * @version 1.0 <br>
//      ************************************************************* <br>
//      */
//     private String functionIF(String formulaStr, Boolean isCheck) throws ParseException
//     {
//         // 括号个数
//         int large_Left = 0, large_Right = 0;
//         // 存括号下标位置
//         int left_num = -1, right_num = -1;
//         char[] chars = formulaStr.toCharArray();
//         HashMap< Integer,Integer > indexMap = new HashMap< Integer,Integer >();
//
//         for (int i = 0; i < chars.length; i++)
//         {
//             char aChar = chars[i];
//             if (aChar == '(')
//             {
//                 large_Left++;
//                 left_num = i;
//                 indexMap.put(large_Left, left_num);
//             }
//             if (aChar == ')')
//             {
//                 large_Right++;
//                 right_num = i;
//             }
//             if (large_Left != 0 && large_Right != 0)
//             {
//                 if (large_Left > large_Right) { left_num = indexMap.get(large_Left); }
//                 if (formulaStr.contains(IPubEvnCons.LEFT_BRACKET) && formulaStr.contains(IPubEvnCons.RIGHT_BRACKET))
//                 {
//                     // (123  != ['123,'125'] and 123  ='124')
//                     formulaStr = parseLinkSymbol(formulaStr, left_num, right_num, isCheck);
//                     formulaStr = functionIF(formulaStr, isCheck);
//                     large_Left = -1;
//                     large_Right = 0;
//                     left_num = -1;
//                     right_num = -1;
//                     indexMap.clear();
//                 }
//             }
//         }
//
//         return formulaStr;
//     }
//
//     /************************************************************* <br>
//      *
//      *说明: 替换括号()里面的内容<br>
//      *
//      * @Description   <br>
//      * @Date Created on 2021/10/9  11:03  <br>
//      * @Param [formulaStr, leftIndex, rightIndex,isCheck] <br>
//      * @return java.lang.String  <br>
//      * @Author LIBENCHENG
//      * @version 1.0 <br>
//      ************************************************************* <br>
//      */
//     private String parseLinkSymbol(String formulaStr, int leftIndex, int rightIndex,
//             Boolean isCheck) throws ParseException
//     {
//         // 函数头
//         String startStr = formulaStr.substring(0, leftIndex).trim();
//         // 函数内容 middle
//         String nodeValue = formulaStr.substring(leftIndex + 1, rightIndex);
//         // 函数尾部
//         String subEndStr = formulaStr.substring(rightIndex + 1, formulaStr.length()).trim();
//
//         return startStr + parseNodeValue(nodeValue, isCheck) + subEndStr;
//     }
//
//     /************************************************************* <br>
//      *
//      *说明:分析条件连接逻辑词 <br>
//      * 核心：看哪个连接词在前在后<br>
//      * @Description   <br>
//      * @Date Created on 2021/10/9  11:03  <br>
//      * @Param [nodeValue] <br>
//      * @return java.lang.Boolean  <br>
//      * @Author LIBENCHENG
//      * @version 1.0 <br>
//      ************************************************************* <br>
//      */
//     private String parseNodeValue(String nodeValue, Boolean isCheck) throws ParseException
//     {
//         String resultStr = nodeValue;
//         AtomicReference< String > nodeValueStr = new AtomicReference<>(nodeValue);
//         if (nodeValue.contains(IPubCons.AND) || nodeValue.contains(IPubCons.OR))
//         {
//             int andInt = nodeValue.indexOf(ISalaryCons.AND);
//             int orInt = nodeValue.indexOf(ISalaryCons.OR);
//             String firstVal = IPubCons.EMPTY;
//             String subVal = IPubCons.EMPTY;
//             if (andInt != -1 && orInt != -1)
//             {
//                 if (andInt < orInt)
//                 {
//                     firstVal = nodeValue.substring(0, andInt);
//                     subVal = nodeValue.substring(andInt + 3, nodeValue.length());
//                     //subVal需要去掉前面的 and 和 or
//                     resultStr = parseNodeValue(firstVal, subVal, Boolean.TRUE, isCheck);
//                 }
//                 else
//                 {
//                     firstVal = nodeValue.substring(0, orInt);
//                     subVal = nodeValue.substring(orInt + 2, nodeValue.length());
//                     resultStr = parseNodeValue(firstVal, subVal, Boolean.FALSE, isCheck);
//                 }
//             }
//             else if (andInt != -1)
//             {
//                 firstVal = nodeValue.substring(0, andInt);
//                 subVal = nodeValue.substring(andInt + 3, nodeValue.length());
//                 resultStr = parseNodeValue(firstVal, subVal, Boolean.TRUE, isCheck);
//             }
//             else if (orInt != -1)
//             {
//                 firstVal = nodeValue.substring(0, orInt);
//                 subVal = nodeValue.substring(orInt + 2, nodeValue.length());
//                 resultStr = parseNodeValue(firstVal, subVal, Boolean.FALSE, isCheck);
//             }
//             if (resultStr.contains(IPubCons.AND) || resultStr.contains(IPubCons.OR))
//             { resultStr = parseNodeValue(resultStr, isCheck); }
//             nodeValueStr.set(resultStr);
//         }
//         // 20220216
//         AtomicReference< Boolean > exist = new AtomicReference<>(Boolean.FALSE);
//         Arrays.stream(ISalaryCons.OPERATE_COMPARE)
//               .forEach(optCompare ->
//                        {
//                            if (nodeValueStr.get().contains(optCompare)) { exist.set(Boolean.TRUE); }
//                        });
//
//         if (exist.get())
//         { resultStr = StringUtil.valueOfZero(parseCompareSymbol(nodeValue, isCheck)); }
//
//         return resultStr;
//     }
//
//     private String parseNodeValue(String firstVal, String subVal, Boolean isAnd, Boolean isCheck) throws
//             ParseException
//     {
//         //subVal需要去掉前面的 and 和 or
//         Boolean result = Boolean.TRUE;
//         String linkStr = "";
//         int andInt = subVal.indexOf(ISalaryCons.AND);
//         int orInt = subVal.indexOf(ISalaryCons.OR);
//         String firstValSub = IPubCons.EMPTY;
//         String subValSub = IPubCons.EMPTY;
//         if (andInt != -1 && orInt != -1)
//         {
//             if (andInt < orInt)
//             {
//                 firstValSub = subVal.substring(0, andInt);
//                 subValSub = subVal.substring(andInt);
//             }
//             else
//             {
//                 firstValSub = subVal.substring(0, orInt);
//                 subValSub = subVal.substring(orInt);
//             }
//         }
//         else if (andInt != -1)
//         {
//             firstValSub = subVal.substring(0, andInt);
//             subValSub = subVal.substring(andInt);
//         }
//         else if (orInt != -1)
//         {
//             firstValSub = subVal.substring(0, orInt);
//             subValSub = subVal.substring(orInt);
//         }
//         else
//         { firstValSub = subVal; }
//         // 各个比较逻辑的表达式的返回结果； 123=123 and 124=123 ==> truefalse
//         linkStr =
//                 StringUtil.valueOfZero(parseCompareSymbol(firstVal.trim(), isCheck)) + parseCompareSymbol(firstValSub.trim(), isCheck);
//         if (isAnd)
//         {
//             // 与只要有一个为false，就为false
//             if (linkStr.contains(IPubCons.FALSE)) { result = Boolean.FALSE; }
//             else { result = Boolean.TRUE; }
//         }
//         else
//         {
//             // 或只要有一个为true，就为true
//             if (linkStr.contains(IPubCons.TRUE)) { result = Boolean.TRUE; }
//             else { result = Boolean.FALSE; }
//         }
//         linkStr = (result + subValSub);
//
//         return linkStr;
//     }
//
//     /************************************************************* <br>
//      *
//      *说明: 分析各种比较运算符<br>
//      *
//      * @Description   <br>
//      * @Date Created on 2021/9/26  16:26  <br>
//      * @Param [nodeValue] <br>
//      * @return java.lang.Boolean  <br>
//      * @Author LIBENCHENG
//      * @version 1.0 <br>
//      ************************************************************* <br>
//      */
//     private Boolean parseCompareSymbol(String nodeValue, Boolean isCheck)
//     {
//         Boolean flag = Boolean.FALSE;
//         if (nodeValue.contains(IPubEvnCons.TRUE) || nodeValue.contains(IPubEvnCons.FALSE))
//         { return Boolean.parseBoolean(nodeValue); }
//
//         // 不等于
//         if (nodeValue.contains(IPubEvnCons.UNEQUALS2))
//         { flag = !optEquals(nodeValue, IPubEvnCons.UNEQUALS2, isCheck); }
//         // 不等于
//         else if (nodeValue.contains(IPubEvnCons.UNEQUALS))
//         { flag = !optEquals(nodeValue, IPubEvnCons.UNEQUALS, isCheck); }
//         // <=
//         else if (nodeValue.contains(IPubEvnCons.EQUALS3))
//         { flag = optUnEquals(nodeValue, IPubEvnCons.EQUALS3, isCheck); }
//         // >=
//         else if (nodeValue.contains(IPubEvnCons.EQUALS4))
//         { flag = optUnEquals(nodeValue, IPubEvnCons.EQUALS4, isCheck); }
//         // 等于
//         else if (nodeValue.contains(IPubEvnCons.EQUALS2))
//         { flag = optEquals(nodeValue, IPubEvnCons.EQUALS2, isCheck); }
//         // 等于
//         else if (nodeValue.contains(IPubEvnCons.EQUALS))
//         { flag = optEquals(nodeValue, IPubEvnCons.EQUALS, isCheck); }
//         // 大于
//         else if (nodeValue.contains(IPubEvnCons.RIGHT_CHEV))
//         { flag = optUnEquals(nodeValue, IPubEvnCons.RIGHT_CHEV, isCheck); }
//         // 小于
//         else if (nodeValue.contains(IPubEvnCons.LEFT_CHEV))
//         { flag = optUnEquals(nodeValue, IPubEvnCons.LEFT_CHEV, isCheck); }
//         else { throw new RuntimeException(formatErrStr(nodeValue + ISalaryMsg.FORMULA_OPT_ERROR)); }
//
//         return flag;
//     }
//
//     /************************************************************* <br>
//      *
//      *说明: 操作除等于，不等于之外的操作比较<br>
//      *
//      * @Description   <br>
//      * @Date Created on 2021/10/22  15:48  <br>
//      * @Param [nodeValue, optType, isCheck] <br>
//      * @return java.lang.Boolean  <br>
//      * @Author LIBENCHENG
//      * @version 1.0 <br>
//      ************************************************************* <br>
//      */
//     private Boolean optUnEquals(String nodeValue, String splitStr, Boolean isCheck)
//     {
//
//         Boolean flag = Boolean.FALSE;
//         String[] values = nodeValue.split(splitStr);
//         if (PubEnvUtil.getSize(values) == 2)
//         {
//             String leftValue = values[0].replace(IPubEvnCons.SINGLE_QUOTE, IPubEvnCons.EMPTY).trim();
//             String rightValue = values[1].replace(IPubEvnCons.SINGLE_QUOTE, IPubEvnCons.EMPTY).trim();
//             if (PubEnvUtil.getSize(leftValue.split(IPubCons.COMMA)) > PubEnvUtil.getSize(rightValue.split(IPubEvnCons.COMMA)))
//             {
//                 String tempValue = leftValue;
//                 leftValue = rightValue;
//                 rightValue = tempValue;
//             }
//
//             if (!DateUtilbc.isValidDateTime(leftValue) && DateUtilbc.isValidDateTime(rightValue))
//             { leftValue = DateUtilbc.currentDateTime(); }
//             else if (isCheck && DateUtilbc.isValidDateTime(rightValue))
//             { leftValue = DateUtilbc.currentDateTime(); }
//             else if (isCheck && !DateUtilbc.isValidDateTime(rightValue))
//             { leftValue = PubEnvUtil.ZERO; }
//             // 20220216
//             // if (checkAlgorithm(leftValue, isCheck))
//             // { leftValue = (calcResult(ISalaryCons.DATA, leftValue, isCheck)); }
//             // if (checkAlgorithm(rightValue, isCheck))
//             // { rightValue = (calcResult(ISalaryCons.DATA, rightValue, isCheck)); }
//             // end
//
//             // <=
//             if (IPubEvnCons.EQUALS3.equals(splitStr))
//             {
//                 if (DateUtilbc.isValidDateTime(leftValue) && DateUtilbc.isValidDateTime(rightValue))
//                 {
//                     flag = (DateUtilbc.isSameDay(new DateTime(leftValue), new DateTime(rightValue))
//                             || new DateTime(leftValue).before(new DateTime(rightValue)));
//                 }
//                 else if (PubEnvUtil.isCalcNumber(leftValue) && PubEnvUtil.isCalcNumber(rightValue))
//                 {
//                     int compare = NumberUtil.compare(PubEnvUtil.parseDouble(leftValue),
//                                                      PubEnvUtil.parseDouble(rightValue));
//                     flag = ((-1 == compare)
//                             || PubEnvUtil.parseDouble(leftValue).equals(PubEnvUtil.parseDouble(rightValue)));
//                 }
//                 else { throw new RuntimeException(formatErrStr(nodeValue + ISalaryMsg.FORMULA_OPT_ERROR)); }
//             }
//             // >=
//             else if (IPubEvnCons.EQUALS4.equals(splitStr))
//             {
//                 if (DateUtilbc.isValidDateTime(leftValue) && DateUtilbc.isValidDateTime(rightValue))
//                 {
//                     flag = (DateUtilbc.isSameDay(new DateTime(leftValue), new DateTime(rightValue))
//                             || new DateTime(leftValue).after(new DateTime(rightValue)));
//                 }
//                 else if (PubEnvUtil.isCalcNumber(leftValue) && PubEnvUtil.isCalcNumber(rightValue))
//                 {
//                     int compare = NumberUtil.compare(PubEnvUtil.parseDouble(leftValue),
//                                                      PubEnvUtil.parseDouble(rightValue));
//                     flag = ((1 == compare)
//                             || PubEnvUtil.parseDouble(leftValue).equals(PubEnvUtil.parseDouble(rightValue)));
//                 }
//                 else { throw new RuntimeException(formatErrStr(nodeValue + ISalaryMsg.FORMULA_OPT_ERROR)); }
//             }
//             // >
//             else if (IPubEvnCons.RIGHT_CHEV.equals(splitStr))
//             {
//                 if (DateUtilbc.isValidDateTime(leftValue) && DateUtilbc.isValidDateTime(rightValue))
//                 { flag = new DateTime(leftValue).after(new DateTime(rightValue)); }
//                 else if (PubEnvUtil.isCalcNumber(leftValue) && PubEnvUtil.isCalcNumber(rightValue))
//                 {
//                     int compare = NumberUtil.compare(PubEnvUtil.parseDouble(leftValue),
//                                                      PubEnvUtil.parseDouble(rightValue));
//                     if (1 == compare) { flag = Boolean.TRUE; }
//                 }
//                 else { throw new RuntimeException(formatErrStr(nodeValue + ISalaryMsg.FORMULA_OPT_ERROR)); }
//             }
//             // <
//             else if (IPubEvnCons.LEFT_CHEV.equals(splitStr))
//             {
//                 if (DateUtilbc.isValidDateTime(leftValue) && DateUtilbc.isValidDateTime(rightValue))
//                 { flag = new DateTime(leftValue).before(new DateTime(rightValue)); }
//                 else if (PubEnvUtil.isCalcNumber(leftValue) && PubEnvUtil.isCalcNumber(rightValue))
//                 {
//                     int compare = NumberUtil.compare(PubEnvUtil.parseDouble(leftValue),
//                                                      PubEnvUtil.parseDouble(rightValue));
//                     if (-1 == compare) { flag = Boolean.TRUE; }
//                 }
//                 else { throw new RuntimeException(formatErrStr(nodeValue + ISalaryMsg.FORMULA_OPT_ERROR)); }
//             }
//             else { throw new RuntimeException(formatErrStr(ISalaryMsg.FORMULA_COMPUTE_ERROR)); }
//         }
//         else { throw new RuntimeException(formatErrStr(ISalaryMsg.FORMULA_COMPUTE_ERROR)); }
//         return flag;
//     }
//
//     /************************************************************* <br>
//      *
//      *说明: 等于(in)和不等于(not)操作 <br>
//      * in相当于=['','','']not in 相当于 !=['','','']<br>
//      * in：123=[123,456,789]/123==[123,456,789]<br>
//      * not in：123!=[123,456,789]/123<>[123,456,789]<br>
//      *  >=和<=     <br>
//      * @Description   <br>
//      * @Date Created on 2021/9/29  15:47  <br>
//      * @Param [nodeValue, splitStr] <br>
//      * @return java.lang.Boolean  <br>
//      * @Author LIBENCHENG
//      * @version 1.0 <br>
//      ************************************************************* <br>
//      */
//     private Boolean optEquals(String nodeValue, String splitStr, Boolean isCheck)
//     {
//         // Boolean flag = Boolean.FALSE;
//         AtomicReference< Boolean > flag = new AtomicReference<>(Boolean.FALSE);
//         AtomicReference< Boolean > isCopy = new AtomicReference<>(Boolean.TRUE);
//
//         // == 和 !=
//         String[] values = nodeValue.split(splitStr);
//         if (PubEnvUtil.getSize(values) == 2)
//         {
//             String leftValue = values[0].replace(IPubEvnCons.SINGLE_QUOTE, IPubEvnCons.EMPTY).trim();
//             String rightValue = values[1].replace(IPubEvnCons.SINGLE_QUOTE, IPubEvnCons.EMPTY).trim();
//             if (PubEnvUtil.getSize(leftValue.split(IPubCons.COMMA)) > PubEnvUtil.getSize(rightValue.split(IPubEvnCons.COMMA)))
//             {
//                 String tempValue = leftValue;
//                 leftValue = rightValue;
//                 rightValue = tempValue;
//             }
//             AtomicReference< String > leftValueAtomic = new AtomicReference< String >(leftValue);
//             // 20220216  bug 0-0=0 问题
//             // if (checkAlgorithm(leftValueAtomic.get(), isCheck))
//             // { leftValueAtomic.set(calcResult(ISalaryCons.DATA, leftValueAtomic.get(), isCheck)); }
//
//             String[] strs = rightValue.replace(IPubEvnCons.LEFT_SQ_BRACKET, IPubEvnCons.EMPTY)
//                                       .replace(IPubEvnCons.RIGHT_SQ_BRACKET, IPubEvnCons.EMPTY)
//                                       .replace(IPubEvnCons.SINGLE_QUOTE, IPubEvnCons.EMPTY)
//                                       .trim()
//                                       .split(IPubEvnCons.COMMA);
//             Arrays.asList(strs)
//                   .stream().forEach(str ->
//                                     {
//                                         if (!flag.get())
//                                         {
//                                             str = str.replace(IPubEvnCons.SINGLE_QUOTE, IPubEvnCons.EMPTY).trim();
//                                             if (isCopy.get())
//                                             {
//                                                 if (!DateUtilbc.isValidDateTime(leftValueAtomic.get()) && DateUtilbc.isValidDateTime(str))
//                                                 { leftValueAtomic.set(DateUtilbc.currentDateTime()); }
//                                                 else if (isCheck && DateUtilbc.isValidDateTime(str))
//                                                 { leftValueAtomic.set(DateUtilbc.currentDateTime()); }
//                                                 else if (isCheck && !DateUtilbc.isValidDateTime(str))
//                                                 { leftValueAtomic.set(PubEnvUtil.ZERO); }
//                                                 isCopy.set(Boolean.FALSE);
//                                             }
//                                             if (PubEnvUtil.equals(leftValueAtomic.get(), str))
//                                             { flag.set(Boolean.TRUE); }
//                                             // 如果是正数、负数、和小数
//                                             if (PubEnvUtil.isCalcNumber(leftValueAtomic.get()) && PubEnvUtil.isCalcNumber(str)
//                                                     && PubEnvUtil.parseDouble(leftValueAtomic.get())
//                                                                  .equals(PubEnvUtil.parseDouble(str)))
//                                             { flag.set(Boolean.TRUE); }
//
//                                             // 如果是时间
//                                             if (DateUtilbc.isValidDateTime(leftValueAtomic.get()) && DateUtilbc.isValidDateTime(str))
//                                             {
//                                                 boolean sameDay =
//                                                         DateUtilbc.isSameDay(new DateTime(leftValueAtomic.get()),
//                                                                              new DateTime(str));
//                                                 flag.set(sameDay);
//                                             }
//                                         }
//                                     });
//         }
//         return flag.get();
//     }
//
//
//     /************************************************************* <br>
//      *
//      *说明: 校验字符串是否包含四则运算<br>
//      *
//      * @Description   <br>
//      * @Date Created on 2021/9/29  13:51  <br>
//      * @Param [nodeValue] <br>
//      * @return java.lang.Boolean  <br>
//      * @Author LIBENCHENG
//      * @version 1.0 <br>
//      ************************************************************* <br>
//      */
//     private Boolean checkAlgorithm(String nodeValue, Boolean isCheck)
//     {
//         // 判断是否是时间串
//         if (DateUtilbc.isValidDateTime(nodeValue)) { return Boolean.FALSE; }
//         AtomicReference< Boolean > exist = new AtomicReference<>(Boolean.FALSE);
//         AtomicReference< String > trmpStr = new AtomicReference<>(nodeValue);
//         if (!PubEnvUtil.isEmpty(nodeValue))
//         {
//             Arrays.stream(ISalaryCons.OPT_SYMBOL)
//                   .forEach(algorithm ->
//                            {
//                                if (nodeValue.contains(algorithm)) { exist.set(Boolean.TRUE); }
//                                trmpStr.set(trmpStr.get().replace(algorithm, IPubCons.EMPTY));
//                            });
//         }
//         //非数字
//         if (exist.get() && !RegularUtil.regExNum.matcher(
//                 trmpStr.get()
//                        .replace(IPubCons.DOT, IPubCons.EMPTY)
//                        .replace(IPubCons.SPACE, IPubCons.EMPTY)
//                        .replace(IPubCons.SINGLE_QUOTE, IPubCons.EMPTY)).matches())
//         { exist.set(Boolean.FALSE); }
//
//         return exist.get();
//     }
//
//     /************************************************************* <br>
//      *
//      *说明: 四则运算校验!
//      * 算术不能包含这些情况："++", "+-", "-+", "+/", "/+", "*+",
//      * "+*", "/-", "-/", "*-", "-*", "**", "*\/","/*", "//"
//      * " +"," -"," *"," /","+ ","- ","& ","/ "<br>
//      *
//      * @Description   <br>
//      * @Date Created on 2022/3/10  15:21  <br>
//      * @param nodeValue <br>
//      * @return void  <br>
//      * @Author LIBENCHENG
//      * @version 1.0 <br>
//      ************************************************************* <br>
//      */
//
//     private void checkFourArithmetic(String nodeValue, Boolean isCheck)
//     {
//         // 去掉运算符后检验是否数字
//         String str = nodeValue.replace(IPubCons.DOT, IPubCons.EMPTY)
//                               .replace(IPubCons.PLUS, IPubCons.EMPTY)
//                               .replace(IPubCons.DASH, IPubCons.EMPTY)
//                               .replace(IPubCons.STAR, IPubCons.EMPTY)
//                               .replace(IPubCons.SLASH, IPubCons.EMPTY)
//                               .replace(IPubCons.SPACE, IPubCons.EMPTY)
//                               .replace(IPubCons.LEFT_BRACKET, IPubCons.EMPTY)
//                               .replace(IPubCons.RIGHT_BRACKET, IPubCons.EMPTY)
//                               .replace(IPubCons.SINGLE_QUOTE, IPubCons.EMPTY);
//         //非数字
//         checkAssert(isCheck && !RegularUtil.regExNum.matcher(str).matches(),
//                     IPubCons.LEFT_SQ_BRACKET + nodeValue + IPubCons.RIGHT_SQ_BRACKET + ISalaryMsg.FORMULA_ERROR);
//         // 校验前去掉空格和括号()
//         String symbol = nodeValue.replace(IPubCons.SPACE, IPubCons.EMPTY)
//                                  .replace(IPubCons.LEFT_BRACKET, IPubCons.EMPTY)
//                                  .replace(IPubCons.LEFT_BRACKET, IPubCons.RIGHT_BRACKET);
//         // 四则运算校验  "++", "+-", "-+", "+/", "/+", "*+", "+*", "/-", "-/", "*-", "-*", "**", "*/", "/*", "//"
//         // Arrays.asList("++", "+-", "-+", "+/", "/+", "*+", "+*", "/-", "-/", "*-", "-*", "**", "*/", "/*", "//")
//         Arrays.asList("++", "-+", "+/", "/+", "*+", "+*", "-/", "-*", "**", "*/", "/*", "//")
//               .forEach(symbolStr ->
//                        {
//                            checkAssert(symbol.contains(symbolStr),
//                                        IPubCons.LEFT_SQ_BRACKET + nodeValue + IPubCons.RIGHT_SQ_BRACKET
//                                                + ISalaryMsg.FORMULA_CHECK_ERROR);
//                        });
//         // 校驗 “ +”，“+ ”，“ -”，" *"."* "," /"，“/ ”
//         Arrays.stream(new String[]{IPubCons.DASH, IPubCons.SLASH, IPubCons.PLUS, IPubCons.STAR})
//               .forEach(symbolStr ->
//                        {
//                            if (!symbol.startsWith(IPubCons.DASH))
//                            {
//                                checkAssert(symbol.startsWith(symbolStr) || symbol.endsWith(symbolStr),
//                                            IPubCons.LEFT_SQ_BRACKET + nodeValue + IPubCons.RIGHT_SQ_BRACKET
//                                                    + ISalaryMsg.FORMULA_CHECK_ERROR);
//                            }
//                        });
//
//     }
//
//     /************************************************************* <br>
//      *
//      *说明:判斷if 和elseif，里面有没有比较操作符 <br>
//      *
//      * @Description   <br>
//      * @Date Created on 2021/9/29  10:24  <br>
//      * @Param [nodeValue] <br>
//      * @return void  <br>
//      * @Author LIBENCHENG
//      * @version 1.0 <br>
//      ************************************************************* <br>
//      */
//     public void checkCompareSymbol(String nodeValue)
//     {
//         nodeValue = nodeValue.trim();
//         checkAssert(!Arrays.asList(IPubEvnCons.LEFT_CHEV, IPubEvnCons.RIGHT_CHEV,
//                                    IPubEvnCons.UNEQUALS, IPubEvnCons.UNEQUALS2,
//                                    IPubEvnCons.EQUALS, IPubEvnCons.EQUALS2)
//                            .contains(nodeValue), ISalaryMsg.FORMULA_OPERATE_ERROR);
//     }
//
//     String valueOfZero(Double dValue)
//     { return dValue.isNaN() ? PubEnvUtil.ZERO : StringUtil.valueOfZero(dValue); }
//
//     public String formatErrStr(String msg)
//     {
//         return StringUtil.toString(
//                 new StringBuilder().append(HRHelper.logSplitStr)
//                                    .append(PubEnvUtil.getSize(salaryDataMap) > 0 ? "公式计算的时候：" :
//                                            "公式校验的时候：")
//                                    .append(formulaKey)
//                                    .append(PubEnvUtil.RN)
//                                    .append(salaryDataMap.get(SalaryDataVO.PERSON_CODE))
//                                    .append("计算的时候-->")
//                                    .append(ISalaryMsg.FORMULA_ERROR)
//                                    .append(IPubCons.AT)
//                                    .append(PubEnvUtil.RN)
//                                    .append("当前公式：")
//                                    .append(formula_parse)
//                                    .append(PubEnvUtil.RN)
//                                    .append("异常详情：[")
//                                    .append(msg)
//                                    .append("] "));
//     }
//
//     private void checkAssert(boolean judge, String message) throws RuntimeException
//     { if (judge) { throw new RuntimeException(formatErrStr(message)); } }
//
//
//     private FormulaHandler( ) { }
//
//     private FormulaHandler(Map< String,Object > pramSalaryDataMap, String formulaParse, String pramformulaKey)
//     {
//         calcAlgorithmStr = PubEnvUtil.EMPTY;
//         formulaKey = pramformulaKey;
//         salaryDataMap = pramSalaryDataMap;
//         formula_parse = formulaParse;
//         calcAlgorithmStr = "";
//
//     }
//
//     public static FormulaHandler getInstance(Map< String,Object > pramSalaryDataMap, String formulaParse,
//             String pramformulaKey)
//     {
//         FormulaHandler df = formulaHandler.get();
//         if (df == null)
//         {
//             df = new FormulaHandler(pramSalaryDataMap, formulaParse, pramformulaKey);
//             formulaHandler.set(df);
//         }
//         return df;
//
//         // return FormulaHandler.InnerFormula.formula;
//     }
//
//     public static FormulaHandler getInstance( )
//     {
//         FormulaHandler df = formulaHandler.get();
//         if (df == null)
//         {
//             df = new FormulaHandler();
//             formulaHandler.set(df);
//         }
//         return df;
//
//         // return FormulaHandler.InnerFormula.formula;
//     }
//
//     private static class InnerFormula
//     {
//         // private static final LoggerUtilbc logger = new LoggerUtilbc();
//         private static FormulaHandler formula = new FormulaHandler();
//
//         //懶漢式
//         public static FormulaHandler getInstance( )
//         {
//             if (null == formula)  //第一层检查，检查是否有引用指向对象，高并发情况下会有多个线程同时进入
//             {
//                 //第一层锁，保证只有一个线程进入
//                 synchronized ( FormulaHandler.InnerFormula.class )
//                 {
//                     //双重检查，防止多个线程同时进入第一层检查(因单例模式只允许存在一个对象，故在创建对象之前无引用指向对象，所有线程均可进入第一层检查)
//                     //当某一线程获得锁创建一个Singleton对象时,即已有引用指向对象，singleton不为空，从而保证只会创建一个对象
//                     //假设没有第二层检查，那么第一个线程创建完对象释放锁后，后面进入对象也会创建对象，会产生多个对象
//                     if (null == formula)    //第二层检查
//                     //volatile关键字作用为禁止指令重排，保证返回Singleton对象一定在创建对象后
//                     { formula = new FormulaHandler(); }
//                     //singleton=new Singleton语句为非原子性，实际上会执行以下内容：
//                     //(1)在堆上开辟空间；(2)属性初始化;(3)引用指向对象
//                     //假设以上三个内容为三条单独指令，因指令重排可能会导致执行顺序为1->3->2(正常为1->2->3),
//                     // 当单例模式中存在普通变量需要在构造方法中进行初始化操作时，单线程情况下，顺序重排没有影响；但在多线程情况下，假如线程1执行singleton=new Singleton()
//                     // 语句时先1再3，由于系统调度线程2的原因没来得及执行步骤2，但此时已有引用指向对象也就是singleton!=null，故线程2在第一次检查时不满足条件直接返回singleton
//                     // ，此时singleton为null(即str值为null)
//                     //volatile关键字可保证singleton=new Singleton()语句执行顺序为123，因其为非原子性依旧可能存在系统调度问题(即执行步骤时被打断)
//                     // ，但能确保的是只要singleton!=0，就表明一定执行了属性初始化操作；而若在步骤3之前被打断，此时singleton依旧为null，其他线程可进入第一层检查向下执行创建对象
//                 }
//             }
//
//             return formula;
//         }
//
//     }
// }
